@wingsky-1/dsh-worktree-sidebar 0.2.5

package/lib/index.js

@@ -0,0 +1,1614 @@
+import { createRequire as __worktreeSidebarRequire } from "node:module";
+const require = __worktreeSidebarRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+
+// lib/shared/contract.js
+var ROUTES = {
+  bindings: "/api/dsh-worktree-sidebar/bindings",
+  health: "/api/dsh-worktree-sidebar/health"
+};
+
+// lib/server/host/agents.js
+function bindAgents(host) {
+  const faceOf = (agent) => ({
+    id: agent.id,
+    cwd: agent.session.header.cwd
+  });
+  return {
+    subscribe: (handler) => host.on("agent/created", ({ agent }) => {
+      handler(faceOf(agent));
+    }),
+    list: () => host.all().map(faceOf),
+    publish: (face, definitions) => {
+      const agent = host.all().find((candidate) => candidate.id === face.id);
+      if (agent === void 0) {
+        throw new Error(`dsh-worktree-sidebar: agent ${face.id} 未注册，拒绝把工具装进未知作用域`);
+      }
+      const disposers = definitions.map((definition) => agent.ctx.tools.register(definition));
+      const disposeTools = () => {
+        for (const dispose2 of disposers) {
+          try {
+            dispose2();
+          } catch {
+          }
+        }
+      };
+      const dispose = agent.ctx.effect(() => disposeTools);
+      return () => {
+        void Promise.resolve(dispose()).catch(() => void 0);
+      };
+    }
+  };
+}
+
+// lib/server/host/sessions.js
+function identityFrom(createdAt) {
+  return Number.isFinite(createdAt) ? { createdAt } : void 0;
+}
+function bindSessions(sessions, storedSessions) {
+  return {
+    liveParentOf: (sessionId) => {
+      const session = sessions.get(sessionId);
+      if (session === void 0)
+        return { kind: "not-live" };
+      const parent = session.header.parentSession;
+      return parent === void 0 ? { kind: "root" } : { kind: "parent", id: parent };
+    },
+    storedParentOf: async (sessionId) => {
+      const stored = storedSessions();
+      if (stored === void 0)
+        return void 0;
+      const snapshot = await stored.stat(sessionId);
+      return snapshot?.header.parentSession;
+    },
+    liveIdentityOf: (sessionId) => {
+      const live = sessions.get(sessionId);
+      return live === void 0 ? void 0 : identityFrom(live.header.createdAt);
+    },
+    storedIdentityOf: async (sessionId) => {
+      const stored = storedSessions();
+      if (stored === void 0)
+        return void 0;
+      const snapshot = await stored.stat(sessionId);
+      return snapshot === void 0 ? void 0 : identityFrom(snapshot.header.createdAt);
+    }
+  };
+}
+
+// lib/server/host/typert.js
+function bindTypert(lookups) {
+  return {
+    current: () => {
+      const descriptor = lookups.get("workspaceFileScope");
+      if (descriptor === void 0)
+        return void 0;
+      const resolve3 = descriptor.resolve.bind(descriptor);
+      return {
+        resolve: async (sessionId) => {
+          const scope = await resolve3(sessionId);
+          if (scope === void 0)
+            return void 0;
+          return { sessionId: scope.sessionId, workspaceRoot: scope.workspaceRoot };
+        }
+      };
+    },
+    subscribe: (listener) => lookups.subscribe(() => listener()),
+    configure: (resolver) => lookups.configure("workspaceFileScope", async (sessionId) => {
+      const scope = await resolver(sessionId);
+      if (scope === void 0)
+        return void 0;
+      return { sessionId, workspaceRoot: scope.workspaceRoot };
+    })
+  };
+}
+
+// ../../shared/loopback.js
+function isLoopbackRequest(request, options = {}) {
+  const address = request.socket?.remoteAddress;
+  if (address !== "127.0.0.1" && address !== "::1" && address !== "::ffff:127.0.0.1") return false;
+  const host = request.headers.host;
+  if (typeof host !== "string") return false;
+  let hostUrl;
+  try {
+    hostUrl = new URL(`http://${host}`);
+  } catch {
+    return false;
+  }
+  if (hostUrl.hostname !== "127.0.0.1" && hostUrl.hostname !== "localhost" && hostUrl.hostname !== "[::1]")
+    return false;
+  if (request.headers["sec-fetch-site"] === "cross-site") {
+    if (!(options.allowCrossSiteNoCors === true && request.headers["sec-fetch-mode"] === "no-cors")) {
+      return false;
+    }
+  }
+  const origin = request.headers.origin;
+  if (origin === void 0) return true;
+  try {
+    return new URL(origin).host === hostUrl.host;
+  } catch {
+    return false;
+  }
+}
+
+// ../../shared/host-utils.js
+function guardLoopbackMethod(req, res, methods, loopbackOptions) {
+  if (!isLoopbackRequest(req, loopbackOptions)) {
+    writeJson(res, 403, { error: "forbidden: loopback-only" });
+    return false;
+  }
+  if (!methods.includes(req.method)) {
+    writeJson(res, 405, { error: `method not allowed: ${req.method}` });
+    return false;
+  }
+  return true;
+}
+function writeJson(res, status, payload) {
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "referrer-policy": "no-referrer"
+  });
+  res.end(JSON.stringify(payload));
+}
+
+// lib/server/api/impl/handlers/index.js
+function queryParam(url, name2) {
+  if (url === void 0)
+    return void 0;
+  const value = new URL(url, "http://placeholder.invalid").searchParams.get(name2);
+  return value === null || value.length === 0 ? void 0 : value;
+}
+function bindingsEndpoint(binding, scope) {
+  return {
+    path: ROUTES.bindings,
+    methods: {
+      GET: async (req, res) => {
+        const session = queryParam(req.url, "session");
+        if (session === void 0) {
+          writeJson(res, 400, { ok: false, error: { message: "缺少 session 参数" } });
+          return;
+        }
+        const worktreePath = await scope.effectiveWorktree(session);
+        const body = { revision: binding.revision(), worktreePath };
+        writeJson(res, 200, body);
+      }
+    }
+  };
+}
+function healthEndpoint(binding, scope) {
+  return {
+    path: ROUTES.health,
+    methods: {
+      GET: (_req, res) => {
+        writeJson(res, 200, {
+          ok: true,
+          revision: binding.revision(),
+          scopeTakeover: scope.takeoverState(),
+          scopeChain: scope.chainDiagnostics()
+        });
+      }
+    }
+  };
+}
+
+// lib/server/api/impl/route/index.js
+function registerEndpoints(register, endpoints, logger) {
+  const disposers = [];
+  for (const endpoint of endpoints) {
+    try {
+      disposers.push(register({
+        kind: "exact",
+        path: endpoint.path,
+        handler: (req, res) => {
+          if (!guardLoopbackMethod(req, res, Object.keys(endpoint.methods)))
+            return;
+          const handle = endpoint.methods[req.method ?? ""];
+          try {
+            const done = handle(req, res);
+            if (done instanceof Promise) {
+              done.catch((cause) => reportFailure(res, logger, cause));
+            }
+          } catch (cause) {
+            reportFailure(res, logger, cause);
+          }
+        }
+      }));
+    } catch (cause) {
+      for (const dispose of [...disposers].reverse()) {
+        try {
+          dispose();
+        } catch {
+        }
+      }
+      throw cause;
+    }
+  }
+  return disposers;
+}
+function reportFailure(res, logger, cause) {
+  const reason = cause instanceof Error ? cause.message : String(cause);
+  logger.warn("dsh-worktree-sidebar: 浏览器端点处理失败 — " + reason);
+  if (!res.headersSent)
+    writeJson(res, 500, { ok: false, error: { message: reason } });
+}
+
+// lib/server/api/impl/service/index.js
+var ApiService = class {
+  /** 是否已装配；单例实例重复装配是编程错误，当场暴露。 */
+  installed = false;
+  /** 已挂路由的摘除器。释放即逐个调用并清空，所以不会叠成两份。 */
+  disposers = [];
+  /** 路由当前是否在册。释放幂等靠它，也靠它区分「没装过」与「已摘完」。 */
+  live = false;
+  /** 装配浏览器出口（组合根在 apply 期调用一次）。重复装配是编程错误，当场暴露。 */
+  install(deps) {
+    if (this.installed)
+      throw new Error("dsh-worktree-sidebar: api 域只能装配一次");
+    const disposers = registerEndpoints(deps.register, [bindingsEndpoint(deps.binding, deps.scope), healthEndpoint(deps.binding, deps.scope)], deps.logger);
+    this.installed = true;
+    this.disposers = disposers;
+    this.live = true;
+  }
+  /** 摘掉全部路由并复位装配标记——同进程的下一次 `install` 会重新注册，且只注册一份。 */
+  release() {
+    this.installed = false;
+    if (!this.live)
+      return;
+    this.live = false;
+    for (const dispose of this.disposers) {
+      try {
+        dispose();
+      } catch {
+      }
+    }
+    this.disposers = [];
+  }
+};
+var apiService = new ApiService();
+
+// lib/server/api/interface.js
+function installApi(deps) {
+  apiService.install(deps);
+}
+function releaseApi() {
+  apiService.release();
+}
+
+// lib/server/binding/interface.js
+var interface_exports = {};
+__export(interface_exports, {
+  BINDINGS_VERSION: () => BINDINGS_VERSION,
+  drop: () => drop,
+  get: () => get,
+  installBinding: () => installBinding,
+  put: () => put,
+  releaseBinding: () => releaseBinding,
+  revision: () => revision
+});
+
+// lib/server/binding/impl/model/type.js
+var BINDINGS_VERSION = 2;
+
+// lib/server/binding/impl/model/index.js
+function emptyTable() {
+  return { version: BINDINGS_VERSION, revision: 0, bindings: {} };
+}
+function validateRecord(value) {
+  if (typeof value !== "object" || value === null)
+    return void 0;
+  const raw = value;
+  const repoRoot = raw["repoRoot"];
+  const worktreeRoot = raw["worktreeRoot"];
+  const branch = raw["branch"];
+  const createdAt = raw["createdAt"];
+  const sessionCreatedAt = raw["sessionCreatedAt"];
+  if (typeof repoRoot !== "string" || repoRoot.length === 0)
+    return void 0;
+  if (typeof worktreeRoot !== "string" || worktreeRoot.length === 0)
+    return void 0;
+  if (typeof branch !== "string")
+    return void 0;
+  if (typeof createdAt !== "string")
+    return void 0;
+  if (typeof sessionCreatedAt !== "number" || !Number.isFinite(sessionCreatedAt))
+    return void 0;
+  return { repoRoot, worktreeRoot, branch, createdAt, sessionCreatedAt };
+}
+function parseTable(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return emptyTable();
+  }
+  if (typeof parsed !== "object" || parsed === null)
+    return emptyTable();
+  const raw = parsed;
+  if (raw["version"] !== BINDINGS_VERSION)
+    return emptyTable();
+  const revision2 = raw["revision"];
+  if (typeof revision2 !== "number" || !Number.isFinite(revision2) || revision2 < 0)
+    return emptyTable();
+  const entries = raw["bindings"];
+  if (typeof entries !== "object" || entries === null)
+    return emptyTable();
+  const bindings = {};
+  for (const [sessionId, value] of Object.entries(entries)) {
+    if (sessionId.length === 0)
+      continue;
+    const record = validateRecord(value);
+    if (record !== void 0)
+      bindings[sessionId] = record;
+  }
+  return { version: BINDINGS_VERSION, revision: revision2, bindings };
+}
+function serializeTable(table) {
+  return JSON.stringify(table, null, 2) + "\n";
+}
+function putBinding(table, sessionId, record) {
+  return {
+    version: table.version,
+    revision: table.revision + 1,
+    bindings: { ...table.bindings, [sessionId]: record }
+  };
+}
+function dropBinding(table, sessionId) {
+  if (!(sessionId in table.bindings))
+    return table;
+  const bindings = { ...table.bindings };
+  delete bindings[sessionId];
+  return { version: table.version, revision: table.revision + 1, bindings };
+}
+
+// lib/server/shared/file-io.js
+import { readFileSync } from "node:fs";
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+function readTextFileSync(file) {
+  try {
+    return { ok: true, text: readFileSync(file, "utf8") };
+  } catch {
+    return { ok: false };
+  }
+}
+async function writeTextAtomic(file, text) {
+  const temporary = `${file}.tmp-${process.pid}`;
+  try {
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(temporary, text, "utf8");
+    await rename(temporary, file);
+    return { ok: true };
+  } catch (cause) {
+    return { ok: false, reason: cause instanceof Error ? cause.message : String(cause) };
+  }
+}
+
+// lib/server/shared/paths.js
+import { join as join2 } from "node:path";
+
+// ../../shared/dsh-home.js
+import { homedir } from "node:os";
+import { join } from "node:path";
+function userHome() {
+  const env = process.platform === "win32" ? process.env.USERPROFILE ?? process.env.HOME : process.env.HOME;
+  return env !== void 0 && env.trim().length > 0 ? env : homedir();
+}
+function dshHome() {
+  const env = process.env.DSH_HOME;
+  return env !== void 0 && env.trim().length > 0 ? env : join(userHome(), ".dsh");
+}
+
+// lib/server/shared/paths.js
+var PACKAGE_DIR = "@wingsky-1/dsh-worktree-sidebar";
+var BINDINGS_FILE_NAME = "bindings.json";
+function bindingsFile() {
+  return join2(dshHome(), PACKAGE_DIR, BINDINGS_FILE_NAME);
+}
+
+// lib/server/binding/impl/store/index.js
+function loadTable(file) {
+  const read = readTextFileSync(file);
+  if (!read.ok)
+    return parseTable("");
+  return parseTable(read.text);
+}
+function saveTable(file, table) {
+  return writeTextAtomic(file, serializeTable(table));
+}
+
+// lib/server/binding/impl/service/index.js
+var NOT_INSTALLED = "dsh-worktree-sidebar: binding 域尚未装配";
+var BindingService = class {
+  /** 是否已装配；单例实例重复装配是编程错误，当场暴露。 */
+  installed = false;
+  deps;
+  table = emptyTable();
+  /**
+   * 写盘串行链：两次并发修改都基于同一份旧表时，后写的那次会静默吞掉前一次的绑定。
+   * 链本身不承载结果，失败也不该断链，故 catch 掉、语义归返回值。
+   */
+  writes = Promise.resolve();
+  /**
+   * 装配代数。`release` 的尾部清理要 `await` 在飞的写盘，那一小段时间里**新的一个
+   * `install` 可能已经装上并从磁盘读回了新表**；无脑清表会抹掉它，紧接着一次 `put`
+   * 就把空表写回磁盘、丢掉所有会话的登记。
+   */
+  generation = 0;
+  /** 装配绑定域：把 bindings.json 读进内存（损坏回落空表，见 model 块）。重复装配是编程错误。 */
+  install(deps) {
+    if (this.installed)
+      throw new Error("dsh-worktree-sidebar: binding 域只能装配一次");
+    this.installed = true;
+    this.generation += 1;
+    this.deps = deps;
+    this.table = loadTable(deps.file);
+  }
+  /**
+   * 卸载：**先等在飞的写盘链落定**，再放开入参、丢掉内存快照、复位装配标记。
+   * 不等的话，同进程的下一次装配会读到比已提交内容更旧的磁盘状态——表现为「刚写的绑定在重装后消失」。
+   * 重复调用无害。
+   */
+  async release() {
+    const generation = ++this.generation;
+    const writes = this.writes;
+    this.installed = false;
+    this.deps = void 0;
+    await writes;
+    if (this.generation !== generation)
+      return;
+    this.writes = Promise.resolve();
+    this.table = emptyTable();
+  }
+  revision() {
+    this.requireInstalled();
+    return this.table.revision;
+  }
+  get(sessionId) {
+    this.requireInstalled();
+    return this.table.bindings[sessionId];
+  }
+  put(sessionId, record) {
+    this.requireInstalled();
+    if (sessionId.length === 0)
+      return Promise.resolve({ ok: false, reason: "空 sessionId" });
+    return this.commit((current) => putBinding(current, sessionId, record));
+  }
+  drop(sessionId) {
+    this.requireInstalled();
+    return this.commit((current) => dropBinding(current, sessionId));
+  }
+  /**
+   * 应用一次表变换并持久化。写盘成功才算成功——半成功的内存状态是最坏结果：
+   * 内存说有、磁盘说没有，重启后就是一次静默的换根失败。
+   *
+   * 入参在**调用当刻**取出：在飞的写盘链要活过 `release`（它等的就是这一步落定），
+   * 而那一刻 `this.deps` 已经被放开了。
+   */
+  commit(reduce) {
+    const deps = this.deps;
+    if (deps === void 0)
+      throw new Error(NOT_INSTALLED);
+    const run = async () => {
+      const next = reduce(this.table);
+      if (next === this.table)
+        return { ok: true };
+      const written = await saveTable(deps.file, next);
+      if (written.ok)
+        this.table = next;
+      else
+        deps.logger.warn("dsh-worktree-sidebar: 绑定表写盘失败 — " + written.reason);
+      return written;
+    };
+    const queued = this.writes.then(run, run);
+    this.writes = queued.catch(() => void 0);
+    return queued;
+  }
+  /** 未装配时能力面当场失败，不拿旧 deps 出结果。 */
+  requireInstalled() {
+    if (this.deps === void 0)
+      throw new Error(NOT_INSTALLED);
+  }
+};
+var bindingService = new BindingService();
+
+// lib/server/binding/interface.js
+function installBinding(deps) {
+  bindingService.install(deps);
+}
+function releaseBinding() {
+  return bindingService.release();
+}
+function revision() {
+  return bindingService.revision();
+}
+function get(sessionId) {
+  return bindingService.get(sessionId);
+}
+function put(sessionId, record) {
+  return bindingService.put(sessionId, record);
+}
+function drop(sessionId) {
+  return bindingService.drop(sessionId);
+}
+
+// lib/server/git/interface.js
+var interface_exports2 = {};
+__export(interface_exports2, {
+  addWorktree: () => addWorktree,
+  belongsTo: () => belongsTo,
+  checkRefFormat: () => checkRefFormat,
+  commonDir: () => commonDir,
+  gitExec: () => gitExec,
+  headBranch: () => headBranch,
+  installGit: () => installGit,
+  listWorktrees: () => listWorktrees,
+  releaseGit: () => releaseGit,
+  removeWorktree: () => removeWorktree,
+  resolveCommit: () => resolveCommit
+});
+
+// lib/server/git/impl/service/index.js
+import { resolve } from "node:path";
+
+// lib/server/git/impl/inspect/index.js
+function commonDirArgs(dir) {
+  return ["-C", dir, "rev-parse", "--git-common-dir"];
+}
+function worktreeListArgs(dir) {
+  return ["-C", dir, "worktree", "list", "--porcelain"];
+}
+function headBranchArgs(dir) {
+  return ["-C", dir, "rev-parse", "--abbrev-ref", "HEAD"];
+}
+function checkRefFormatArgs(branch) {
+  return ["check-ref-format", "--branch", branch];
+}
+function addWorktreeArgs(repoRoot, path, branch, base) {
+  const flags = branch === void 0 ? ["--detach"] : ["-b", branch];
+  const startPoint = base === void 0 ? [] : [base];
+  return ["-C", repoRoot, "worktree", "add", ...flags, "--", path, ...startPoint];
+}
+function revParseCommitArgs(dir, rev) {
+  return ["-C", dir, "rev-parse", "--verify", "--quiet", rev + "^{commit}"];
+}
+function removeWorktreeArgs(repoRoot, path, force) {
+  const flags = force ? ["--force"] : [];
+  return ["-C", repoRoot, "worktree", "remove", ...flags, "--", path];
+}
+function parseSingleLine(stdout) {
+  const line = stdout.split("\n")[0]?.trim() ?? "";
+  return line.length === 0 ? void 0 : line;
+}
+function parseWorktreeList(stdout) {
+  const entries = [];
+  for (const block of stdout.split(/\r?\n\r?\n/)) {
+    let path;
+    let branch;
+    let detached = false;
+    for (const rawLine of block.split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (line.startsWith("worktree "))
+        path = line.slice("worktree ".length);
+      else if (line.startsWith("branch "))
+        branch = line.slice("branch ".length);
+      else if (line === "detached")
+        detached = true;
+    }
+    if (path !== void 0 && path.length > 0)
+      entries.push({ path, branch, detached });
+  }
+  return entries;
+}
+
+// lib/server/git/impl/service/index.js
+var BELONGS_TTL_MS = 3e4;
+var BELONGS_CACHE_MAX = 256;
+var COMMON_DIR_TTL_MS = 3e4;
+var COMMON_DIR_CACHE_MAX = 256;
+var NOT_INSTALLED2 = "dsh-worktree-sidebar: git 域尚未装配";
+var GitService = class {
+  /** 是否已装配；单例实例重复装配是编程错误，当场暴露。 */
+  installed = false;
+  /** 装配入参。释放即放开，能力面随之当场失败。 */
+  deps;
+  belongsCache = /* @__PURE__ */ new Map();
+  /** 只放正结果，所以值不是 `string | undefined`——负结果没有条目。 */
+  commonDirCache = /* @__PURE__ */ new Map();
+  /** 装配 git 域。重复装配是编程错误，当场暴露。 */
+  install(deps) {
+    if (this.installed)
+      throw new Error("dsh-worktree-sidebar: git 域只能装配一次");
+    this.installed = true;
+    this.deps = deps;
+  }
+  /** 卸载：丢掉缓存与装配入参，复位装配标记——同进程的下一次 `install` 不该撞上「只能装配一次」。 */
+  release() {
+    this.installed = false;
+    this.belongsCache.clear();
+    this.commonDirCache.clear();
+    this.deps = void 0;
+  }
+  async commonDir(dir) {
+    const reading = await this.reading(dir);
+    return reading.kind === "repo" ? reading.dir : void 0;
+  }
+  /**
+   * 带缓存的仓库判定读数。缓存只认正结果（见 `COMMON_DIR_TTL_MS`），负结果每次都真问一次 git。
+   */
+  async reading(dir) {
+    const hit = this.commonDirCache.get(dir);
+    if (hit !== void 0 && Date.now() - hit.at < COMMON_DIR_TTL_MS) {
+      return { kind: "repo", dir: hit.dir };
+    }
+    const reading = await this.computeCommonDir(dir);
+    if (reading.kind === "repo") {
+      if (this.commonDirCache.size >= COMMON_DIR_CACHE_MAX)
+        this.commonDirCache.clear();
+      this.commonDirCache.set(dir, { at: Date.now(), dir: reading.dir });
+    }
+    return reading;
+  }
+  /** 真起一次 git 求公共目录；缓存命中不走这里。 */
+  async computeCommonDir(dir) {
+    const result = await this.exec().run(commonDirArgs(dir));
+    if (!result.ok) {
+      return result.code === null ? { kind: "failed", reason: reasonOf(result) } : { kind: "not-repo" };
+    }
+    const value = parseSingleLine(result.stdout);
+    if (value === void 0)
+      return { kind: "failed", reason: "git 未返回公共 git 目录" };
+    return { kind: "repo", dir: resolve(dir, value) };
+  }
+  async listWorktrees(dir) {
+    const result = await this.exec().run(worktreeListArgs(dir));
+    if (!result.ok)
+      return [];
+    return parseWorktreeList(result.stdout);
+  }
+  async belongsTo(dir, repoRoot) {
+    const key = dir + "\0" + repoRoot;
+    const hit = this.belongsCache.get(key);
+    if (hit !== void 0 && Date.now() - hit.at < BELONGS_TTL_MS)
+      return hit.reading;
+    const [left, right] = await Promise.all([this.reading(dir), this.reading(repoRoot)]);
+    const reading = left.kind === "repo" && right.kind === "repo" ? left.dir === right.dir ? { kind: "same" } : { kind: "different" } : {
+      kind: "unknown",
+      reason: unreadableReason(dir, left, repoRoot, right),
+      notRepo: left.kind === "not-repo" || right.kind === "not-repo"
+    };
+    if (reading.kind !== "unknown") {
+      if (this.belongsCache.size >= BELONGS_CACHE_MAX)
+        this.belongsCache.clear();
+      this.belongsCache.set(key, { at: Date.now(), reading });
+    }
+    return reading;
+  }
+  async headBranch(dir) {
+    const result = await this.exec().run(headBranchArgs(dir));
+    if (!result.ok)
+      return void 0;
+    const value = parseSingleLine(result.stdout);
+    if (value === void 0 || value === "HEAD")
+      return void 0;
+    return value;
+  }
+  async checkRefFormat(branch) {
+    const result = await this.exec().run(checkRefFormatArgs(branch));
+    return result.ok;
+  }
+  async addWorktree(repoRoot, path, branch, base) {
+    const result = await this.exec().run(addWorktreeArgs(repoRoot, path, branch, base));
+    return result.ok ? { ok: true } : { ok: false, reason: reasonOf(result) };
+  }
+  /** 解析起点。`--quiet` 让「不是有效 rev」走退出码而不是 stderr，失败在这里就收成 undefined。 */
+  async resolveCommit(dir, rev) {
+    const result = await this.exec().run(revParseCommitArgs(dir, rev));
+    if (!result.ok)
+      return void 0;
+    return parseSingleLine(result.stdout);
+  }
+  async removeWorktree(repoRoot, path, force) {
+    const result = await this.exec().run(removeWorktreeArgs(repoRoot, path, force));
+    return result.ok ? { ok: true } : { ok: false, reason: reasonOf(result) };
+  }
+  /** 取执行面：未装配时当场失败，而不是拿一份空执行面跑出「git 说没有」这种假答案。 */
+  exec() {
+    const deps = this.deps;
+    if (deps === void 0)
+      throw new Error(NOT_INSTALLED2);
+    return deps.exec;
+  }
+};
+var gitService = new GitService();
+function reasonOf(result) {
+  const text = result.stderr.trim();
+  return text.length > 0 ? text : "git 退出码非零";
+}
+function unreadableReason(dir, left, repoRoot, right) {
+  const sides = [];
+  const describe = (label, path, reading) => {
+    if (reading.kind === "repo")
+      return;
+    const why = reading.kind === "failed" ? "git 执行失败（" + reading.reason + "）" : "不是 git 工作树";
+    sides.push(label + " " + path + " " + why);
+  };
+  describe("worktree 侧", dir, left);
+  describe("主仓库侧", repoRoot, right);
+  return sides.join("；");
+}
+
+// lib/server/git/impl/exec/index.js
+import { execFile } from "node:child_process";
+var TIMEOUT_MS = 1e4;
+var MAX_BUFFER = 4 * 1024 * 1024;
+var gitExec = {
+  run: (args) => new Promise((resolve3) => {
+    execFile("git", [...args], { timeout: TIMEOUT_MS, maxBuffer: MAX_BUFFER, windowsHide: true }, (error, stdout, stderr) => {
+      const detail = stderr.length > 0 ? stderr : error === null ? "" : error.message;
+      const code = error === null ? 0 : typeof error.code === "number" ? error.code : null;
+      resolve3({ ok: error === null, stdout, stderr: detail, code });
+    });
+  })
+};
+
+// lib/server/git/interface.js
+function installGit(deps) {
+  gitService.install(deps);
+}
+function releaseGit() {
+  gitService.release();
+}
+function commonDir(dir) {
+  return gitService.commonDir(dir);
+}
+function listWorktrees(dir) {
+  return gitService.listWorktrees(dir);
+}
+function belongsTo(dir, repoRoot) {
+  return gitService.belongsTo(dir, repoRoot);
+}
+function headBranch(dir) {
+  return gitService.headBranch(dir);
+}
+function checkRefFormat(branch) {
+  return gitService.checkRefFormat(branch);
+}
+function addWorktree(repoRoot, path, branch, base) {
+  return gitService.addWorktree(repoRoot, path, branch, base);
+}
+function resolveCommit(dir, rev) {
+  return gitService.resolveCommit(dir, rev);
+}
+function removeWorktree(repoRoot, path, force) {
+  return gitService.removeWorktree(repoRoot, path, force);
+}
+
+// lib/server/scope/interface.js
+var interface_exports3 = {};
+__export(interface_exports3, {
+  chainDiagnostics: () => chainDiagnostics,
+  effectiveWorktree: () => effectiveWorktree2,
+  installScope: () => installScope,
+  releaseScope: () => releaseScope,
+  rootOf: () => rootOf,
+  takeoverState: () => takeoverState,
+  worktreeOrigin: () => worktreeOrigin
+});
+
+// lib/server/scope/impl/own/index.js
+import { statSync } from "node:fs";
+function realStat(path) {
+  return statSync(path, { throwIfNoEntry: false });
+}
+function directoryExists(path, stat = realStat) {
+  try {
+    return stat(path)?.isDirectory() === true;
+  } catch {
+    return true;
+  }
+}
+async function ownRecord(deps, sessionId) {
+  const record = deps.binding.get(sessionId);
+  if (record === void 0)
+    return void 0;
+  const exists = deps.existsDirectory ?? directoryExists;
+  if (!exists(record.worktreeRoot)) {
+    await drop2(deps, sessionId, "worktree 目录不存在：" + record.worktreeRoot);
+    return void 0;
+  }
+  const identity = await identityOf(deps, sessionId);
+  if (identity !== void 0 && identity.createdAt !== record.sessionCreatedAt) {
+    await drop2(deps, sessionId, "会话 id 已被另一个会话复用（登记属于 createdAt=" + record.sessionCreatedAt + "，当前会话是 " + identity.createdAt + "）：" + record.worktreeRoot);
+    return void 0;
+  }
+  const belongs = await deps.git.belongsTo(record.worktreeRoot, record.repoRoot);
+  if (belongs.kind === "different") {
+    await drop2(deps, sessionId, "已不是该仓库的 worktree：" + record.worktreeRoot);
+    return void 0;
+  }
+  if (belongs.kind === "unknown") {
+    deps.logger.warn("dsh-worktree-sidebar: 无法确认 worktree 归属，保留该会话的登记 — " + belongs.reason);
+  }
+  return record;
+}
+async function identityOf(deps, sessionId) {
+  const live = deps.sessions.liveIdentityOf(sessionId);
+  if (live !== void 0)
+    return live;
+  try {
+    return await deps.sessions.storedIdentityOf(sessionId);
+  } catch (cause) {
+    deps.logger.warn("dsh-worktree-sidebar: 无法核对会话身份，保留该会话的登记 — " + (cause instanceof Error ? cause.message : String(cause)));
+    return void 0;
+  }
+}
+async function drop2(deps, sessionId, reason) {
+  deps.logger.warn("dsh-worktree-sidebar: " + reason + " —— 已摘掉该会话的登记");
+  try {
+    const dropped = await deps.binding.drop(sessionId);
+    if (!dropped.ok) {
+      deps.logger.warn("dsh-worktree-sidebar: 摘除失效绑定失败 — " + dropped.reason);
+    }
+  } catch (cause) {
+    deps.logger.warn("dsh-worktree-sidebar: 摘除失效绑定抛出 — " + (cause instanceof Error ? cause.message : String(cause)));
+  }
+}
+
+// lib/server/scope/impl/inherit/index.js
+async function inheritedOrigin(deps, sessionId) {
+  const seen = /* @__PURE__ */ new Set([sessionId]);
+  let current = sessionId;
+  for (; ; ) {
+    const parent = await parentOf(deps, current);
+    if (parent === void 0 || seen.has(parent))
+      return void 0;
+    seen.add(parent);
+    const inherited = await ownRecord(deps, parent);
+    if (inherited !== void 0)
+      return { record: inherited, ownerSessionId: parent };
+    current = parent;
+  }
+}
+async function parentOf(deps, sessionId) {
+  const live = deps.sessions.liveParentOf(sessionId);
+  if (live.kind === "parent")
+    return live.id;
+  if (live.kind === "root")
+    return void 0;
+  try {
+    return await deps.sessions.storedParentOf(sessionId);
+  } catch {
+    return void 0;
+  }
+}
+
+// lib/server/scope/impl/resolve/index.js
+function rootOf(origin) {
+  return origin.kind === "none" ? null : origin.record.worktreeRoot;
+}
+async function bindingOrigin(deps, sessionId) {
+  const own = await ownRecord(deps, sessionId);
+  if (own !== void 0)
+    return { kind: "own", record: own };
+  const inherited = await inheritedOrigin(deps, sessionId);
+  if (inherited !== void 0) {
+    return {
+      kind: "inherited",
+      record: inherited.record,
+      ownerSessionId: inherited.ownerSessionId
+    };
+  }
+  return { kind: "none" };
+}
+async function effectiveWorktree(deps, sessionId) {
+  return rootOf(await bindingOrigin(deps, sessionId));
+}
+async function resolveScope(deps, delegate, sessionId) {
+  try {
+    const root = await effectiveWorktree(deps, sessionId);
+    if (root !== null)
+      return { sessionId, workspaceRoot: root };
+  } catch (cause) {
+    deps.logger.warn("dsh-worktree-sidebar: 解析文件根失败，回退官方语义 — " + (cause instanceof Error ? cause.message : String(cause)));
+  }
+  try {
+    return await delegate(sessionId);
+  } catch (cause) {
+    deps.logger.warn("dsh-worktree-sidebar: 官方默认解析失败 — " + (cause instanceof Error ? cause.message : String(cause)));
+    return void 0;
+  }
+}
+
+// lib/server/scope/impl/service/index.js
+var NOT_INSTALLED3 = "dsh-worktree-sidebar: scope 域尚未装配";
+var ScopeService = class {
+  state = "idle";
+  deps;
+  /** 捕获到的委托对象。释放即丢掉，不留在实例上供下一次装配复用。 */
+  delegate;
+  /** configure 交回的释放面：调用它官方默认解析即恢复。 */
+  dispose;
+  /** 查找表订阅的退订面。等待期需要它，进入终态后它只是空转。 */
+  unsubscribe;
+  /** 等待期只出一次声：通知可能来很多次，每次都报会把日志淹掉。 */
+  warnedWaiting = false;
+  /** 持久面读数。跨调用存活，所以只能住在这里，不能住在 `inherit`（那是无状态函数）。 */
+  chain = { storedReads: 0, storedFailures: 0, lastFailure: void 0 };
+  /** 装配 scope 域。重复装配是编程错误，当场暴露。 */
+  install(deps) {
+    if (this.state !== "idle")
+      throw new Error("dsh-worktree-sidebar: scope 域只能装配一次");
+    this.chain = { storedReads: 0, storedFailures: 0, lastFailure: void 0 };
+    this.deps = { ...deps, sessions: this.observed(deps.sessions) };
+    this.state = "waiting";
+    this.unsubscribe = deps.typert.subscribe(() => this.attempt());
+    this.attempt();
+  }
+  /**
+   * 卸载：把 resolver 交还官方、退订、丢掉捕获到的委托与装配入参，复位状态。重复调用无害。
+   * 此后到达的解析请求回 undefined（gateway 走它自己的 lookup-not-found），不会拿旧 deps 继续服务。
+   */
+  release() {
+    const unsubscribe = this.unsubscribe;
+    const dispose = this.dispose;
+    this.state = "idle";
+    this.deps = void 0;
+    this.delegate = void 0;
+    this.dispose = void 0;
+    this.unsubscribe = void 0;
+    this.warnedWaiting = false;
+    this.chain = { storedReads: 0, storedFailures: 0, lastFailure: void 0 };
+    if (unsubscribe !== void 0) {
+      try {
+        unsubscribe();
+      } catch {
+      }
+    }
+    if (dispose === void 0)
+      return;
+    try {
+      dispose();
+    } catch {
+    }
+  }
+  takeoverState() {
+    return this.state;
+  }
+  /** 读数是快照：调用方拿不到本域内部那个对象，改不动它。 */
+  chainDiagnostics() {
+    return { ...this.chain };
+  }
+  /**
+   * 给会话链的持久面加一圈读数。失败**照原样抛回**，收口仍在调用方——
+   * 这里只负责记账，不改变任何判定。
+   *
+   * 身份核对也走同一条持久面，所以它同样计入读数：只统计父链会让「身份读不出来」这类
+   * 故障在 health 上完全不可见。
+   */
+  observed(inner) {
+    return {
+      liveParentOf: (sessionId) => inner.liveParentOf(sessionId),
+      storedParentOf: (sessionId) => this.counted(() => inner.storedParentOf(sessionId)),
+      liveIdentityOf: (sessionId) => inner.liveIdentityOf(sessionId),
+      storedIdentityOf: (sessionId) => this.counted(() => inner.storedIdentityOf(sessionId))
+    };
+  }
+  /** 记一次持久面读取：无论成败都算一次读，抛错另计一次失败并留下最后原因。 */
+  async counted(read) {
+    this.chain.storedReads += 1;
+    try {
+      return await read();
+    } catch (cause) {
+      this.chain.storedFailures += 1;
+      this.chain.lastFailure = cause instanceof Error ? cause.message : String(cause);
+      throw cause;
+    }
+  }
+  async effectiveWorktree(sessionId) {
+    const deps = this.deps;
+    if (deps === void 0)
+      throw new Error(NOT_INSTALLED3);
+    if (this.state !== "live")
+      return null;
+    return effectiveWorktree(deps, sessionId);
+  }
+  /**
+   * 绑定来源。**不设 takeover 门**：登记是否存在与「文件根是否已经换成它」是两件事，
+   * 工具面（register / create / remove）要的是前者的完整答案——它据此决定能不能摘、
+   * 该不该报「继承自哪个会话」。把工具面也卡在 `live` 上，接管冲突时连一条已确认失效的
+   * 登记都清理不掉。
+   */
+  async worktreeOrigin(sessionId) {
+    const deps = this.deps;
+    if (deps === void 0)
+      throw new Error(NOT_INSTALLED3);
+    return bindingOrigin(deps, sessionId);
+  }
+  /**
+   * 试一次接管。provider 没出现就退回等待态，等待由查找表的变更通知再次叫醒。
+   */
+  attempt() {
+    if (this.state !== "waiting")
+      return;
+    const deps = this.deps;
+    if (deps === void 0)
+      return;
+    const descriptor = deps.typert.current();
+    if (descriptor === void 0) {
+      if (!this.warnedWaiting) {
+        this.warnedWaiting = true;
+        deps.logger.warn("dsh-worktree-sidebar: workspaceFileScope 的 provider 尚未注册，先等它出现（文件根暂按官方语义）");
+      }
+      return;
+    }
+    const delegate = descriptor.resolve;
+    this.delegate = delegate;
+    this.state = "live";
+    try {
+      this.dispose = deps.typert.configure((sessionId) => this.resolve(sessionId));
+    } catch (cause) {
+      const reason = cause instanceof Error ? cause.message : String(cause);
+      this.state = "abandoned";
+      this.delegate = void 0;
+      this.dispose = void 0;
+      deps.logger.warn("dsh-worktree-sidebar: workspaceFileScope 已有解析器，放弃接管（文件根保持官方语义）— " + reason);
+    }
+  }
+  /**
+   * 交给官方 typert 的解析器。委托对象与装配入参都按**调用当刻**取：释放之后这个闭包只剩
+   * undefined，官方拿到的是它自己的 lookup-not-found，而不是一份过期绑定。
+   */
+  async resolve(sessionId) {
+    const deps = this.deps;
+    const delegate = this.delegate;
+    if (deps === void 0 || delegate === void 0)
+      return void 0;
+    return resolveScope(deps, delegate, sessionId);
+  }
+};
+var scopeService = new ScopeService();
+
+// lib/server/scope/interface.js
+function installScope(deps) {
+  scopeService.install(deps);
+}
+function releaseScope() {
+  scopeService.release();
+}
+function effectiveWorktree2(sessionId) {
+  return scopeService.effectiveWorktree(sessionId);
+}
+function worktreeOrigin(sessionId) {
+  return scopeService.worktreeOrigin(sessionId);
+}
+function takeoverState() {
+  return scopeService.takeoverState();
+}
+function chainDiagnostics() {
+  return scopeService.chainDiagnostics();
+}
+
+// lib/server/tools/impl/bind/index.js
+import { statSync as statSync2 } from "node:fs";
+import { isAbsolute, resolve as resolve2 } from "node:path";
+var NO_ORIGIN = { kind: "none" };
+async function readOrigin(deps, sessionId) {
+  try {
+    return { origin: await deps.scope.worktreeOrigin(sessionId), problem: void 0 };
+  } catch (cause) {
+    deps.logger.warn("dsh-worktree-sidebar: 读取绑定来源失败 —— " + (cause instanceof Error ? cause.message : String(cause)));
+    return {
+      origin: NO_ORIGIN,
+      problem: "Could not read this session's binding state. Retry once the extension is fully loaded."
+    };
+  }
+}
+function stateOf(origin) {
+  if (origin.kind === "none")
+    return { bound: false, worktree: "", branch: "" };
+  return { bound: true, worktree: origin.record.worktreeRoot, branch: origin.record.branch };
+}
+function resultOf(origin, ok, detail) {
+  const state = stateOf(origin);
+  const inherited = origin.kind === "inherited" ? "This root is inherited from session " + origin.ownerSessionId + "; this session has no binding of its own. " : "";
+  return {
+    ok,
+    bound: state.bound,
+    worktree: state.worktree,
+    branch: state.branch,
+    detail: inherited + detail
+  };
+}
+function resolveTarget(cwd, raw) {
+  return isAbsolute(raw) ? raw : resolve2(cwd, raw);
+}
+function directoryProblem(target) {
+  const info = statSync2(target, { throwIfNoEntry: false });
+  if (info === void 0)
+    return "No such directory: " + target;
+  if (!info.isDirectory())
+    return "Not a directory: " + target;
+  return void 0;
+}
+async function availableWorktrees(deps, repo) {
+  const entries = await deps.git.listWorktrees(repo);
+  if (entries.length === 0)
+    return "";
+  return "\nAvailable worktrees:\n" + entries.map((entry) => "- " + entry.path).join("\n");
+}
+async function bindWorktree(deps, session, repo, target, registeredAt, before) {
+  if (session.createdAt === void 0) {
+    return resultOf(before, false, "This session exposes no creation timestamp, so the binding could not be told apart from a different session that reuses the same id after a restart. Refusing to bind.");
+  }
+  const belongs = await deps.git.belongsTo(target, repo);
+  if (belongs.kind !== "same") {
+    const why = belongs.kind === "different" || belongs.kind === "unknown" && belongs.notRepo ? "That directory is not a worktree of this session's repository (" + repo + "), so binding it would point the file tree outside this repository." : "Could not verify that the directory belongs to this session's repository (" + repo + "): " + (belongs.kind === "unknown" ? belongs.reason : "") + ". Retry once the directory is readable.";
+    return resultOf(before, false, why + await availableWorktrees(deps, repo));
+  }
+  const branch = await deps.git.headBranch(target) ?? "";
+  const record = {
+    repoRoot: repo,
+    worktreeRoot: target,
+    branch,
+    createdAt: registeredAt,
+    sessionCreatedAt: session.createdAt
+  };
+  const written = await deps.binding.put(session.id, record);
+  if (!written.ok) {
+    return resultOf(before, false, "Could not persist the binding: " + written.reason);
+  }
+  return resultOf({ kind: "own", record }, true, "Bound this session to the worktree. Open or refresh the right-sidebar Files tab to see it; the session cwd is unchanged, and @ references / present targets still resolve against the cwd.");
+}
+async function repoOf(deps, agent) {
+  if (agent.cwd === void 0)
+    return void 0;
+  const common = await deps.git.commonDir(agent.cwd);
+  return common === void 0 ? void 0 : agent.cwd;
+}
+
+// lib/server/tools/impl/protocol/index.js
+var RESULT_SCHEMA = {
+  type: "object",
+  properties: {
+    ok: { type: "boolean", description: "Whether the requested operation succeeded." },
+    bound: {
+      type: "boolean",
+      description: "Whether a worktree is bound to this session or inherited from a parent session after the call."
+    },
+    worktree: {
+      type: "string",
+      description: "Absolute path of the bound worktree; empty when bound is false."
+    },
+    branch: {
+      type: "string",
+      description: "Bound branch name; empty when bound is false or the worktree is detached."
+    },
+    detail: {
+      type: "string",
+      description: "What happened: for failures, the reason and the next thing to try; for successes, the effect."
+    }
+  },
+  required: ["ok", "bound", "worktree", "branch", "detail"],
+  additionalProperties: false
+};
+function renderResult(value) {
+  const state = value.bound ? "bound worktree: " + value.worktree + (value.branch === "" ? "" : " [" + value.branch + "]") : "no worktree bound to this session";
+  return [{ type: "text", text: state + "\n" + value.detail }];
+}
+function argString(args, key) {
+  if (typeof args !== "object" || args === null)
+    return void 0;
+  const value = args[key];
+  if (typeof value !== "string")
+    return void 0;
+  const trimmed = value.trim();
+  return trimmed.length === 0 ? void 0 : trimmed;
+}
+function argBool(args, key) {
+  if (typeof args !== "object" || args === null)
+    return false;
+  return args[key] === true;
+}
+
+// lib/server/tools/impl/session/index.js
+function sessionOf(exec) {
+  if (typeof exec !== "object" || exec === null)
+    return void 0;
+  const session = readObject(readObject(exec, "agent"), "session");
+  if (session === void 0)
+    return void 0;
+  const id = session.id;
+  if (typeof id !== "string" || id.length === 0)
+    return void 0;
+  const header = readObject(session, "header");
+  const cwd = header === void 0 ? void 0 : header.cwd;
+  const createdAt = header === void 0 ? void 0 : header.createdAt;
+  return {
+    id,
+    cwd: typeof cwd === "string" && cwd.length > 0 ? cwd : void 0,
+    createdAt: typeof createdAt === "number" && Number.isFinite(createdAt) ? createdAt : void 0
+  };
+}
+function readObject(source, key) {
+  if (typeof source !== "object" || source === null)
+    return void 0;
+  const value = source[key];
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+
+// lib/server/tools/impl/create/index.js
+function buildCreateTool(deps) {
+  return {
+    name: "ws_worktree_create",
+    description: "Create a git worktree from this session's repository with git worktree add, then bind it to THIS session so the right-sidebar Files tab is rooted at it (open or refresh that tab to see the new root). The session cwd does not change. Prefer this over a bare git worktree add when the Files tab should show the new worktree: a bare git command creates the directory but leaves the Files tab rooted at the session cwd (for a worktree you created that way, call ws_worktree_register on it instead). Path and branch are yours to choose; the plugin imposes no layout convention. base defaults to the current HEAD of the repository the session working directory is in, so pass it explicitly when you need a different start point. If git worktree add succeeds but binding fails, the directory is left in place and the result says so. Whether the Files tab then actually follows the binding is reported by GET /api/dsh-worktree-sidebar/health as scopeTakeover.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Where to create the worktree: an absolute path, or a path relative to the session working directory."
+        },
+        branch: {
+          type: "string",
+          description: "Optional branch to create for the worktree (git worktree add -b). Validated with git check-ref-format --branch before git is called. Omit to check out the start point detached (git worktree add --detach): that is base, or the repository HEAD when base is omitted too. Creating no branch also works for paths whose last segment is not a valid branch name."
+        },
+        base: {
+          type: "string",
+          description: "Optional start point (commit-ish: branch, tag, or SHA, e.g. origin/main). Defaults to the current HEAD of the repository the session working directory is in."
+        }
+      },
+      required: ["path"],
+      additionalProperties: false
+    },
+    output: {
+      schema: RESULT_SCHEMA,
+      render: (_args, value) => renderResult(value)
+    },
+    execute: async (args, exec) => {
+      const session = sessionOf(exec);
+      if (session === void 0) {
+        return resultOf(NO_ORIGIN, false, "This tool needs an agent session, and the call carries none. Run it as an agent tool call.");
+      }
+      if (session.cwd === void 0) {
+        return resultOf(NO_ORIGIN, false, "This session has no working directory, so it cannot be checked against a git repository.");
+      }
+      const repo = session.cwd;
+      if (await deps.git.commonDir(repo) === void 0) {
+        return resultOf(NO_ORIGIN, false, "This session is not inside a git repository.");
+      }
+      const raw = argString(args, "path");
+      if (raw === void 0) {
+        return resultOf(NO_ORIGIN, false, "Missing required parameter: path.");
+      }
+      const read = await readOrigin(deps, session.id);
+      if (read.problem !== void 0)
+        return resultOf(read.origin, false, read.problem);
+      const origin = read.origin;
+      const target = resolveTarget(repo, raw);
+      const branch = argString(args, "branch");
+      if (branch !== void 0 && !await deps.git.checkRefFormat(branch)) {
+        return resultOf(origin, false, "Not a valid git branch name: " + branch + " (git check-ref-format --branch rejected it).");
+      }
+      const base = argString(args, "base");
+      if (base !== void 0 && base.startsWith("-")) {
+        return resultOf(origin, false, "Not a valid start point: " + base + ' (a start point must not begin with "-").');
+      }
+      let startPoint;
+      if (base !== void 0) {
+        startPoint = await deps.git.resolveCommit(repo, base);
+        if (startPoint === void 0) {
+          return resultOf(origin, false, "Not a valid start point: " + base + ".");
+        }
+      }
+      const created = await deps.git.addWorktree(repo, target, branch, startPoint);
+      if (!created.ok) {
+        return resultOf(origin, false, "git worktree add failed: " + created.reason);
+      }
+      const bound = await bindWorktree(deps, session, repo, target, deps.now(), origin);
+      if (!bound.ok) {
+        return {
+          ...bound,
+          detail: "The worktree was created at " + target + ", but binding it to this session failed: " + bound.detail + " The directory is left in place: bind it with ws_worktree_register, or remove it with git worktree remove -- " + target
+        };
+      }
+      return {
+        ...bound,
+        detail: "Created the worktree and bound this session to it. Open or refresh the right-sidebar Files tab to see it; the session cwd is unchanged."
+      };
+    }
+  };
+}
+
+// lib/server/tools/impl/remove/index.js
+function inheritedHelp(ownerSessionId, cwd) {
+  const main = "Nothing to unbind here: the Files tab root belongs to session " + ownerSessionId + ", not to this session. To stop following it: (1) unbind it in that session with ws_worktree_remove, or (2) bind this session to another worktree with ws_worktree_create / ws_worktree_register.";
+  if (cwd === void 0)
+    return main;
+  return main + ' A third option, when that session is gone: bind this session to its own working directory with ws_worktree_register({ worktree: "' + cwd + '" }), which makes this session stop inheriting.';
+}
+function buildRemoveTool(deps) {
+  return {
+    name: "ws_worktree_remove",
+    description: "Unbind the worktree from THIS session; the right-sidebar Files tab returns to the session cwd on its next open or refresh. This only touches this session's own binding: when the Files tab follows a root inherited from a parent session instead, the tool refuses (it never unbinds or removes another session's worktree) and reports which session owns that root plus the ways to stop following it. By default the worktree directory is left in place - pass removeDirectory: true to also run git worktree remove, and force: true as well when it has uncommitted changes you accept losing. The plugin never deletes directories itself.",
+    parameters: {
+      type: "object",
+      properties: {
+        removeDirectory: {
+          type: "boolean",
+          description: "Also remove the worktree directory with git worktree remove. Defaults to false: only the binding is dropped."
+        },
+        force: {
+          type: "boolean",
+          description: "Adds --force to git worktree remove, discarding uncommitted changes. Only valid together with removeDirectory: true."
+        }
+      },
+      additionalProperties: false
+    },
+    output: {
+      schema: RESULT_SCHEMA,
+      render: (_args, value) => renderResult(value)
+    },
+    execute: async (args, exec) => {
+      const session = sessionOf(exec);
+      if (session === void 0) {
+        return resultOf(NO_ORIGIN, false, "This tool needs an agent session, and the call carries none. Run it as an agent tool call.");
+      }
+      const read = await readOrigin(deps, session.id);
+      if (read.problem !== void 0)
+        return resultOf(read.origin, false, read.problem);
+      const origin = read.origin;
+      if (origin.kind === "inherited") {
+        return resultOf(origin, false, inheritedHelp(origin.ownerSessionId, session.cwd));
+      }
+      if (origin.kind === "none") {
+        return resultOf(origin, false, "No worktree is bound to this session, so there is nothing to unbind.");
+      }
+      const removeDirectory = argBool(args, "removeDirectory");
+      const force = argBool(args, "force");
+      if (force && !removeDirectory) {
+        return resultOf(origin, false, "force only applies together with removeDirectory: true; the binding is unchanged.");
+      }
+      if (!removeDirectory) {
+        const dropped2 = await deps.binding.drop(session.id);
+        if (!dropped2.ok) {
+          return resultOf(origin, false, "Could not persist the unbind: " + dropped2.reason);
+        }
+        const after2 = await readOrigin(deps, session.id);
+        if (after2.problem !== void 0) {
+          return resultOf(after2.origin, true, "Unbound this session's own binding. The Files tab root could not be read back: " + after2.problem);
+        }
+        return resultOf(after2.origin, true, after2.origin.kind === "inherited" ? "Unbound this session's own binding. The Files tab now follows the root inherited from session " + after2.origin.ownerSessionId + "." : "Unbound the worktree from this session. The directory was left in place; open or refresh the Files tab to return to the session cwd.");
+      }
+      const removed = await deps.git.removeWorktree(origin.record.repoRoot, origin.record.worktreeRoot, force);
+      if (!removed.ok) {
+        return resultOf(origin, false, "git worktree remove failed: " + removed.reason + " The binding is unchanged.");
+      }
+      const dropped = await deps.binding.drop(session.id);
+      if (!dropped.ok) {
+        return resultOf(origin, false, "Removed the worktree directory, but the binding could not be dropped: " + dropped.reason + " It is now stale and will be treated as unbound; call this tool again to retry the unbind.");
+      }
+      const after = await readOrigin(deps, session.id);
+      if (after.problem !== void 0) {
+        return resultOf(after.origin, true, "Unbound this session and removed the worktree directory with git worktree remove. The Files tab root could not be read back: " + after.problem);
+      }
+      return resultOf(after.origin, true, after.origin.kind === "inherited" ? "Unbound this session and removed the worktree directory with git worktree remove. The Files tab now follows the root inherited from session " + after.origin.ownerSessionId + "." : "Unbound this session and removed the worktree directory with git worktree remove.");
+    }
+  };
+}
+
+// lib/server/tools/impl/register/index.js
+function buildRegisterTool(deps) {
+  return {
+    name: "ws_worktree_register",
+    description: "Bind an existing git worktree to THIS session, so the right-sidebar Files tab is rooted at that worktree once you open or refresh it. The session cwd does not change. Use this when the directory already exists - including a worktree you created with a bare git worktree add, which creates the directory but leaves the Files tab on the session cwd; use ws_worktree_create when the worktree still has to be created. Only the Files tab follows the binding: @ file references, present targets and the skill catalog still resolve against the session cwd, and under the workspace-write file policy the agent cannot write into the worktree. If this session inherits a root from a parent session, binding here overrides that inherited root for this session only. Whether the Files tab then actually follows the binding is reported by GET /api/dsh-worktree-sidebar/health as scopeTakeover.",
+    parameters: {
+      type: "object",
+      properties: {
+        worktree: {
+          type: "string",
+          description: "The worktree to bind: an absolute path, or a path relative to the session working directory."
+        }
+      },
+      required: ["worktree"],
+      additionalProperties: false
+    },
+    output: {
+      schema: RESULT_SCHEMA,
+      render: (_args, value) => renderResult(value)
+    },
+    execute: async (args, exec) => {
+      const session = sessionOf(exec);
+      if (session === void 0) {
+        return resultOf(NO_ORIGIN, false, "This tool needs an agent session, and the call carries none. Run it as an agent tool call.");
+      }
+      if (session.cwd === void 0) {
+        return resultOf(NO_ORIGIN, false, "This session has no working directory, so it cannot be checked against a git repository.");
+      }
+      if (await deps.git.commonDir(session.cwd) === void 0) {
+        return resultOf(NO_ORIGIN, false, "This session is not inside a git repository.");
+      }
+      const raw = argString(args, "worktree");
+      if (raw === void 0) {
+        return resultOf(NO_ORIGIN, false, "Missing required parameter: worktree.");
+      }
+      const read = await readOrigin(deps, session.id);
+      if (read.problem !== void 0)
+        return resultOf(read.origin, false, read.problem);
+      const origin = read.origin;
+      const target = resolveTarget(session.cwd, raw);
+      const problem = directoryProblem(target);
+      if (problem !== void 0) {
+        return resultOf(origin, false, problem + await availableWorktrees(deps, session.cwd));
+      }
+      return bindWorktree(deps, session, session.cwd, target, deps.now(), origin);
+    }
+  };
+}
+
+// lib/server/tools/impl/service/index.js
+var ToolsService = class {
+  /** 是否已装配；单例实例重复装配是编程错误，当场暴露。 */
+  installed = false;
+  deps;
+  /** 每个 agent 的工具摘除器。释放时逐个调用并清空，下一次装配才装得进同一个 agent。 */
+  perAgent = /* @__PURE__ */ new Map();
+  unsubscribe;
+  // 判定要走一次 git，是异步的；不串行化的话两个同时发布的 agent 会各自看到「尚未注册」，
+  // 于是同一个 agent 被装两遍。
+  chain = Promise.resolve();
+  /**
+   * 装配代数。在飞的异步判定跨过一次 release 就作废——否则它会把上一代的 deps 装进新一代，
+   * 而那种串味的症状是「工具装了但绑的是上一个装配体的表」。
+   */
+  generation = 0;
+  /** 装配工具域。重复装配是编程错误，当场暴露。 */
+  install(deps) {
+    if (this.installed)
+      throw new Error("dsh-worktree-sidebar: tools 域只能装配一次");
+    this.installed = true;
+    this.deps = deps;
+    const generation = this.generation;
+    const consider = (agent) => this.consider(generation, agent);
+    this.unsubscribe = deps.agents.subscribe(consider);
+    for (const agent of deps.agents.list())
+      consider(agent);
+  }
+  /**
+   * 卸载：退订、逐个摘掉每个 agent 的工具、丢掉映射与在飞的异步链，复位装配标记。重复调用无害。
+   * 映射必须清空——留着它下一次装配会把同一个 agent 当成「已装过」直接跳过，工具永远装不上。
+   */
+  release() {
+    this.installed = false;
+    this.generation += 1;
+    this.deps = void 0;
+    const unsubscribe = this.unsubscribe;
+    this.unsubscribe = void 0;
+    if (unsubscribe !== void 0) {
+      try {
+        unsubscribe();
+      } catch {
+      }
+    }
+    for (const dispose of [...this.perAgent.values()].reverse()) {
+      try {
+        dispose();
+      } catch {
+      }
+    }
+    this.perAgent.clear();
+    this.chain = Promise.resolve();
+  }
+  /** 判定一个 agent 是否该装工具，该装就装。同一个 agent 只处理一次。 */
+  consider(generation, agent) {
+    this.chain = this.chain.then(async () => {
+      const deps = this.deps;
+      if (deps === void 0)
+        return;
+      if (generation !== this.generation || this.perAgent.has(agent.id))
+        return;
+      if (await repoOf(deps, agent) === void 0)
+        return;
+      if (generation !== this.generation || this.perAgent.has(agent.id))
+        return;
+      const definitions = [
+        buildRegisterTool(deps),
+        buildCreateTool(deps),
+        buildRemoveTool(deps)
+      ];
+      this.perAgent.set(agent.id, deps.agents.publish(agent, definitions));
+    }).catch((cause) => {
+      const deps = this.deps;
+      if (deps === void 0 || generation !== this.generation)
+        return;
+      const reason = cause instanceof Error ? cause.message : String(cause);
+      deps.logger.warn("dsh-worktree-sidebar: 工具注册失败 — " + reason);
+    });
+  }
+};
+var toolsService = new ToolsService();
+
+// lib/server/tools/interface.js
+function installTools(deps) {
+  toolsService.install(deps);
+}
+function releaseTools() {
+  toolsService.release();
+}
+
+// lib/index.js
+var name = "worktree-sidebar";
+var inject = ["webServer", "agents", "typert", "sessions"];
+async function apply(ctx, config = {}) {
+  const host = {
+    logger: ctx.logger,
+    register: (route) => ctx.webServer.register(route),
+    agents: bindAgents({
+      on: (event, handler) => ctx.on(event, handler),
+      all: () => ctx.agents.list()
+    }),
+    typert: bindTypert(ctx.typert.lookups),
+    sessions: bindSessions(ctx.sessions, () => storedSessionsOf(ctx)),
+    now: () => (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const disposers = await assemble(host, config);
+  ctx.effect(() => () => safeDisposeAll(disposers));
+}
+function storedSessionsOf(ctx) {
+  return ctx.get("sessionPersistence");
+}
+async function assemble(host, config) {
+  const disposers = [];
+  if (config.enabled === false)
+    return disposers;
+  try {
+    installBinding({ logger: host.logger, file: bindingsFile() });
+    disposers.push(releaseBinding);
+    installGit({ exec: gitExec });
+    disposers.push(releaseGit);
+    installScope({
+      logger: host.logger,
+      binding: interface_exports,
+      git: interface_exports2,
+      typert: host.typert,
+      sessions: host.sessions
+    });
+    disposers.push(releaseScope);
+    installTools({
+      logger: host.logger,
+      binding: interface_exports,
+      git: interface_exports2,
+      scope: interface_exports3,
+      agents: host.agents,
+      now: host.now
+    });
+    disposers.push(releaseTools);
+    installApi({
+      register: host.register,
+      logger: host.logger,
+      binding: interface_exports,
+      scope: interface_exports3
+    });
+    disposers.push(releaseApi);
+  } catch (cause) {
+    await safeDisposeAll(disposers);
+    throw cause;
+  }
+  return disposers;
+}
+async function safeDisposeAll(disposers) {
+  for (const dispose of [...disposers].reverse()) {
+    try {
+      await dispose();
+    } catch {
+    }
+  }
+}
+export {
+  ROUTES,
+  apply,
+  inject,
+  name
+};