codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/workstream-imports.js

@@ -0,0 +1,177 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workstream_imports_exports = {};
+__export(workstream_imports_exports, {
+  importsAdded: () => importsAdded,
+  importsReadableFor: () => importsReadableFor,
+  ruleImports: () => ruleImports
+});
+module.exports = __toCommonJS(workstream_imports_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_ast_parser = require("./ast-parser");
+var import_database = require("./database");
+var import_resolvers = require("./resolvers");
+var import_package_entry = require("../../shared/lib/package-entry");
+var import_symbol_entry = require("../../shared/lib/symbol-entry");
+var import_call_entry = require("../../shared/lib/call-entry");
+var import_folder_entry = require("../../shared/lib/folder-entry");
+var import_grep_entry = require("../../shared/lib/grep-entry");
+var import_patterns = require("./patterns");
+var import_importers = require("./importers");
+var import_check_words = require("../../shared/lib/check-words");
+var import_branch_workstreams = require("./branch-workstreams");
+var import_workstream_symbols = require("./workstream-symbols");
+var import_architecture_rules = require("./architecture-rules");
+var import_architecture_rule = require("./architecture-rule");
+const MAX_CACHED = 5e3;
+const cache = /* @__PURE__ */ new Map();
+const posix = (p) => p.split(import_node_path.default.sep).join("/");
+function stampOf(folder, base, file, head) {
+  if (head) return `${base}|${head}|${file.status}|${file.from ?? ""}`;
+  let st = "gone";
+  try {
+    const s = import_node_fs.default.statSync(import_node_path.default.join(folder, file.path));
+    st = `${s.size}:${s.mtimeMs}:${s.ctimeMs}`;
+  } catch {
+  }
+  return `${base}|${file.status}|${file.from ?? ""}|${st}`;
+}
+async function importsAdded(projectRoot, w, mainRoot, opts = {}) {
+  const base = w.changes.base;
+  const branch = w.shape === "branch" && w.head && mainRoot ? w.head : null;
+  const folder = branch ? mainRoot : w.root;
+  const read = async (rel) => branch ? (0, import_branch_workstreams.showAtAsync)(mainRoot, branch, rel) : (0, import_workstream_symbols.currentContent)(w.root, rel);
+  const known = new Set((0, import_database.getAllFileHashes)().keys());
+  for (const f of w.changes.files) if (f.status !== "deleted") known.add(import_node_path.default.join(projectRoot, f.path));
+  const { aliasMap, systems } = (0, import_database.getImportResolutionContext)(projectRoot);
+  const targets = (rel, content, scopeRel = rel, lines) => {
+    const out = /* @__PURE__ */ new Set();
+    if (content === null) return out;
+    for (const rule of opts.grep ?? []) if ((0, import_architecture_rules.grepReads)(rule, scopeRel)) for (const e of (0, import_grep_entry.grepEntries)(rule, content)) out.add(e);
+    const abs = import_node_path.default.join(projectRoot, rel);
+    let parsed = null;
+    try {
+      parsed = (0, import_ast_parser.parseVirtualFile)(abs, content);
+    } catch {
+      parsed = null;
+    }
+    if (opts.files) out.add((0, import_folder_entry.fileFact)(rel, parsed ? (0, import_folder_entry.exportCount)(parsed.language, parsed.symbols) : null));
+    if (!parsed) return out;
+    if (opts.calls) {
+      for (const cs of parsed.callsites ?? []) {
+        const e = (0, import_call_entry.callEntry)(cs);
+        if (!e) continue;
+        out.add(e);
+        if (lines && cs.line && !lines.has(e)) lines.set(e, cs.line);
+      }
+    }
+    const resolver = (0, import_resolvers.getResolverForLanguage)(parsed.language);
+    if (!resolver) return out;
+    for (const imp of parsed.imports) {
+      const hit = resolver.resolve({ importSource: imp.source, importerPath: abs, projectRoot, knownFiles: known, aliasMap, systems, isRelative: imp.isRelative });
+      if (hit) out.add(posix(import_node_path.default.relative(projectRoot, hit)));
+      if (hit && opts.symbols && !imp.isReexport) {
+        const names = imp.isNamespace ? ["*"] : [...imp.specifiers, ...imp.isDefault ? ["default"] : []];
+        for (const name of names) {
+          for (const origin of (0, import_importers.originsOf)(hit, name)) out.add((0, import_symbol_entry.symbolEntry)(posix(import_node_path.default.relative(projectRoot, origin)), name));
+        }
+      } else if (opts.packages) {
+        const entry = (0, import_package_entry.packageEntry)(parsed.language, imp.source, imp.isRelative);
+        if (entry) out.add(entry);
+      }
+    }
+    return out;
+  };
+  const edges = [];
+  for (const file of w.changes.files) {
+    if (file.status === "deleted") continue;
+    const key = `${folder}\0${file.path}\0${opts.packages ? "p" : ""}${opts.symbols ? "s" : ""}${opts.calls ? `c${(0, import_patterns.patternStamp)(projectRoot)}` : ""}${opts.files ? "f" : ""}${(opts.grep ?? []).map((r) => `g${(0, import_grep_entry.grepKey)(r)}${r.in?.join(",")}|${r.except.join(",")}`).join("")}`;
+    const stamp = stampOf(folder, base, file, branch);
+    const hit = cache.get(key);
+    if (hit && hit.stamp === stamp) {
+      edges.push(...hit.added);
+      continue;
+    }
+    const beforePath = file.status === "renamed" && file.from ? file.from : file.path;
+    const lines = /* @__PURE__ */ new Map();
+    const after = targets(file.path, await read(file.path), file.path, lines);
+    const before = file.status === "added" || !base ? /* @__PURE__ */ new Set() : targets(beforePath, await (0, import_workstream_symbols.baseContent)(folder, base, beforePath), file.path);
+    const added = [...after].filter((t) => !before.has(t)).sort().map((to) => ({ from: file.path, to, ...lines.has(to) ? { line: lines.get(to) } : {} }));
+    if (cache.size >= MAX_CACHED) cache.clear();
+    cache.set(key, { stamp, added });
+    edges.push(...added);
+  }
+  return edges;
+}
+const real = (p) => {
+  try {
+    return import_node_fs.default.realpathSync(p);
+  } catch {
+    return import_node_path.default.resolve(p);
+  }
+};
+function importsReadableFor(projectRoot) {
+  const held = (0, import_database.resolutionContextRoot)();
+  return !!held && real(held) === real(projectRoot);
+}
+async function ruleImports(projectRoot, files, base, judgeBy) {
+  const rules = judgeBy ? [...judgeBy] : (0, import_architecture_rules.rulesOf)(projectRoot);
+  if (rules.length === 0) return [];
+  if (!importsReadableFor(projectRoot)) return null;
+  const edges = await importsAdded(projectRoot, {
+    root: projectRoot,
+    shape: "shared",
+    head: null,
+    changes: { base, files: files.map((f) => ({ path: f, status: "modified" })), truncated: false }
+  }, null, { packages: true, symbols: rules.some((r) => r.kind === "symbol"), calls: rules.some((r) => r.kind === "calls"), files: rules.some((r) => r.kind === "folder"), grep: rules.filter((r) => r.kind === "grep" && r.strength !== "guide") });
+  const byId = new Map(rules.map((r) => [r.id, r]));
+  const lineOf = new Map(edges.filter((e) => e.line).map((e) => [`${e.from}>${e.to}`, e.line]));
+  return (0, import_architecture_rules.checkEdges)(rules, edges).map((b) => {
+    const rule = byId.get(b.rule);
+    const line = lineOf.get(`${b.from}>${b.to}`);
+    return {
+      path: b.from,
+      imports: b.to,
+      ...line ? { line } : {},
+      rule: rule.id,
+      words: (0, import_architecture_rules.ruleStatement)({ ...rule, except: [] }),
+      because: rule.because,
+      strength: rule.strength === "block" ? "block" : "warn",
+      // B3: a look-alike's fix says how alike, and what it is like.
+      suite: rule.suite ?? "architecture",
+      fix: (0, import_architecture_rule.lookAlikeFix)(rule, b.to) ?? (0, import_check_words.ruleFix)(rule)
+    };
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  importsAdded,
+  importsReadableFor,
+  ruleImports
+});

package/src/backend/services/workstream-service.js

@@ -0,0 +1,335 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workstream_service_exports = {};
+__export(workstream_service_exports, {
+  INLINE_SYMBOL_FILES: () => INLINE_SYMBOL_FILES,
+  MAX_WATCHED_TREES: () => MAX_WATCHED_TREES,
+  branchSymbolsWarmed: () => branchSymbolsWarmed,
+  deriveWorkstreams: () => deriveWorkstreams,
+  discoverAround: () => discoverAround,
+  getSymbolParser: () => getSymbolParser,
+  listWorkstreamPlaces: () => listWorkstreamPlaces,
+  listWorkstreams: () => listWorkstreams,
+  setClaudeSessionSource: () => setClaudeSessionSource,
+  setSymbolParser: () => setSymbolParser,
+  treesToWatch: () => treesToWatch,
+  workstreamBranches: () => workstreamBranches
+});
+module.exports = __toCommonJS(workstream_service_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_worktree_service = require("./worktree-service");
+var import_session_service = require("./session-service");
+var import_intent_service = require("./intent-service");
+var import_workstream_watch_service = require("./workstream-watch-service");
+var import_workstream_symbols = require("./workstream-symbols");
+var import_branch_workstreams = require("./branch-workstreams");
+var import_project_config_service = require("./project-config-service");
+var import_trusted_roots = require("./trusted-roots");
+var import_git_env = require("./git-env");
+var import_recent_projects_service = require("./recent-projects-service");
+const NO_CHANGES = { base: null, files: [], truncated: false };
+const isClaude = (agentType) => agentType.toLowerCase().includes("claude");
+function deriveWorkstreams(input) {
+  const realpath = input.realpath ?? import_node_fs.default.realpathSync.native;
+  const canon = (p) => {
+    try {
+      return realpath(p);
+    } catch {
+      return p;
+    }
+  };
+  const trees = input.worktrees.filter((w) => !w.bare && !w.prunable);
+  const byCanon = new Map(trees.map((w) => [canon(w.path), w.path]));
+  const agentsIn = new Map(trees.map((w) => [w.path, []]));
+  const logsIn = /* @__PURE__ */ new Map();
+  for (const s of input.mcpSessions) {
+    if (s.status !== "active" || !s.workstreamRoot) continue;
+    const tree = byCanon.get(canon(s.workstreamRoot));
+    if (!tree) continue;
+    agentsIn.get(tree).push({
+      sessionId: s.sessionId,
+      agentType: s.agentType,
+      model: s.model ?? null,
+      source: "mcp",
+      lastSeen: s.lastSeen
+    });
+  }
+  for (const s of input.claudeSessions) {
+    const tree = byCanon.get(canon(s.workstreamRoot));
+    if (!tree) continue;
+    logsIn.set(tree, [...logsIn.get(tree) ?? [], s]);
+  }
+  return trees.map((w) => {
+    const agents = agentsIn.get(w.path);
+    const connectedClaude = agents.filter((a) => isClaude(a.agentType)).length;
+    for (const log of (logsIn.get(w.path) ?? []).slice(connectedClaude)) {
+      agents.push({ sessionId: log.sessionId, agentType: "claude-code", model: null, source: "claude-log", lastSeen: null });
+    }
+    const changes = input.changes?.(w.path) ?? NO_CHANGES;
+    return {
+      root: w.path,
+      branch: w.branch,
+      head: w.head,
+      main: w.isMain,
+      shape: agents.length >= 2 ? "shared" : "worktree",
+      agents,
+      changes,
+      // Spec §4.1: idle is no agent AND no changes. A worktree an agent left
+      // with work in it is still a line of work.
+      idle: agents.length === 0 && changes.files.length === 0
+    };
+  });
+}
+let claudeSource = () => [];
+function setClaudeSessionSource(source) {
+  claudeSource = source;
+}
+let symbolParser = null;
+function setSymbolParser(parse) {
+  symbolParser = parse;
+}
+function getSymbolParser() {
+  return symbolParser;
+}
+async function listWorkstreams(projectRoot, opts = {}) {
+  let all;
+  if (opts.fresh) {
+    all = await listAll(projectRoot, true);
+  } else {
+    let p = listing.get(projectRoot);
+    if (!p) {
+      p = listAll(projectRoot, false).finally(() => listing.delete(projectRoot));
+      listing.set(projectRoot, p);
+    }
+    all = await p;
+  }
+  return opts.includeIdle ? [...all] : all.filter((w) => !w.idle);
+}
+const CHANGES_CONCURRENCY = 6;
+const listing = /* @__PURE__ */ new Map();
+async function listAll(projectRoot, fresh) {
+  let claudeSessions = [];
+  try {
+    claudeSessions = claudeSource();
+  } catch {
+  }
+  const listed = await (0, import_worktree_service.listWorktreesAsync)(projectRoot);
+  const worktrees = listed.length ? listed : [{ path: projectRoot, branch: null, head: null, isMain: true, isCurrent: true, bare: false, prunable: false }];
+  const main = worktrees.find((w) => w.isMain);
+  const mainRef = main?.branch ?? main?.head ?? null;
+  const clones = listed.length ? await cloneTrees(projectRoot, worktrees) : [];
+  const cloneRoots = new Set(clones.map((c) => c.path));
+  const trees = [...worktrees, ...clones];
+  const changesOf = /* @__PURE__ */ new Map();
+  const folders = [...new Set(trees.filter((w) => !w.bare && !w.prunable).map((w) => w.path))];
+  const todo = [...folders.filter((f) => f === projectRoot), ...folders.filter((f) => f !== projectRoot)];
+  let symbolBudget = INLINE_SYMBOL_FILES;
+  const later = [];
+  const measure = async () => {
+    for (let folder = todo.shift(); folder !== void 0; folder = todo.shift()) {
+      const changes = await (0, import_workstream_watch_service.getChanges)(folder, mainRef, { fresh });
+      if (!symbolParser) {
+        changesOf.set(folder, changes);
+        continue;
+      }
+      const pending = (0, import_workstream_symbols.uncachedSymbolFiles)(folder, changes);
+      if (pending <= symbolBudget) {
+        symbolBudget -= pending;
+        changesOf.set(folder, await (0, import_workstream_symbols.withSymbolChanges)(folder, changes, symbolParser));
+      } else {
+        changesOf.set(folder, changes);
+        later.push({ folder, changes });
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: CHANGES_CONCURRENCY }, measure));
+  const derived = deriveWorkstreams({
+    worktrees: trees,
+    // Sessions read after the awaits above, so an agent that connected meanwhile is placed.
+    mcpSessions: (0, import_session_service.getActiveSessions)(),
+    claudeSessions,
+    changes: (folder) => changesOf.get(folder)
+  });
+  const all = derived.map((w) => cloneRoots.has(w.root) ? { ...w, shape: "clone" } : w);
+  (0, import_workstream_watch_service.syncWorkstreamWatchers)(
+    treesToWatch(all, projectRoot).map((folder) => ({ folder, mainRef })),
+    all.map((w) => w.root)
+  ).catch(() => {
+  });
+  const branches = main && listed.length ? await branchWorkstreams(main.path, main.branch, mainRef, worktrees, projectRoot) : [];
+  if (main && listed.length) void (0, import_workstream_watch_service.watchRefs)(main.path).catch(() => {
+  });
+  warmSymbols(`${main?.path ?? projectRoot}\0trees`, main?.path ?? projectRoot, later);
+  return withIntents([...all, ...branches]);
+}
+const MAX_WATCHED_TREES = 16;
+function treesToWatch(all, projectRoot, max = Number(process.env.CODETRELLIS_MAX_WATCHED_TREES) || MAX_WATCHED_TREES) {
+  const rank = (w) => w.agents.length > 0 ? 2 + w.agents.length : w.main || w.root === projectRoot ? 1 : 0;
+  return all.map((w, i) => ({ w, i })).filter(({ w }) => !w.idle).sort((a, b) => rank(b.w) - rank(a.w) || a.i - b.i).slice(0, max).map(({ w }) => w.root);
+}
+async function listWorkstreamPlaces(projectRoot) {
+  const worktrees = await (0, import_worktree_service.listWorktreesAsync)(projectRoot);
+  if (!worktrees.length) return [];
+  const trees = [...worktrees, ...await cloneTrees(projectRoot, worktrees)].filter((w) => !w.bare && !w.prunable);
+  const places = trees.map((w) => ({ root: w.path, branch: w.branch }));
+  const checkedOut = new Set(trees.map((w) => w.branch).filter((b) => Boolean(b)));
+  const main = worktrees.find((w) => w.isMain) ?? worktrees[0];
+  let refs = [];
+  try {
+    refs = (await (0, import_git_env.gitAsync)(main.path, ["for-each-ref", "--format=%(refname)%00%(refname:short)", "refs/heads", "refs/remotes"])).split("\n").map((line) => {
+      const [ref, short] = line.split("\0");
+      return { ref, short };
+    }).filter((r) => r.ref && r.short && !r.ref.endsWith("/HEAD"));
+  } catch {
+  }
+  const local = new Set(refs.filter((r) => r.ref.startsWith("refs/heads/")).map((r) => r.short));
+  for (const r of refs) {
+    if (checkedOut.has(r.short)) continue;
+    if (r.ref.startsWith("refs/remotes/") && local.has(r.short.split("/").slice(1).join("/"))) continue;
+    places.push({ root: `branch:${r.short}`, branch: r.short });
+  }
+  return places;
+}
+async function discoverAround(folder) {
+  if ((0, import_workstream_watch_service.isWatchedFolder)(folder)) return;
+  for (const root of (0, import_trusted_roots.listTrustedRoots)()) {
+    try {
+      if (root !== folder && !(await (0, import_worktree_service.listWorktreesAsync)(root)).some((w) => w.path === folder)) continue;
+      await listWorkstreams(root, { includeIdle: true });
+    } catch {
+    }
+  }
+}
+async function workstreamBranches(projectRoot) {
+  const worktrees = await (0, import_worktree_service.listWorktreesAsync)(projectRoot);
+  const main = worktrees.find((w) => w.isMain);
+  if (!main) return [];
+  const mainRef = main.branch ?? main.head ?? null;
+  const out = worktrees.filter((w) => !w.isMain && w.branch).map((w) => w.branch);
+  for (const b of await branchWorkstreams(main.path, main.branch, mainRef, worktrees, projectRoot)) {
+    if (!b.idle && b.branch && !out.includes(b.branch)) out.push(b.branch);
+  }
+  return out;
+}
+function withIntents(all) {
+  return all.map((w) => {
+    const intents = w.agents.map((a) => (0, import_intent_service.getIntent)(a.sessionId)).filter((i) => i !== null);
+    return intents.length ? { ...w, intents } : w;
+  });
+}
+async function branchWorkstreams(repo, mainBranch, mainRef, worktrees, projectRoot) {
+  let windowDays;
+  try {
+    windowDays = (0, import_project_config_service.getEffectiveSensorConfig)(projectRoot).awareness.branchWindowDays;
+  } catch {
+    windowDays = 7;
+  }
+  const checkedOut = new Set(worktrees.map((w) => w.branch).filter((b) => !!b));
+  const out = [];
+  let symbolBudget = INLINE_SYMBOL_FILES;
+  const later = [];
+  for (const b of await (0, import_branch_workstreams.branchWorkstreamsOf)(repo, { mainBranch, mainRef, checkedOut, windowDays })) {
+    const atCommit = { head: b.head, read: (rel) => (0, import_branch_workstreams.showAtAsync)(repo, b.head, rel) };
+    let changes = b.changes;
+    if (symbolParser) {
+      const pending = (0, import_workstream_symbols.uncachedSymbolFiles)(repo, b.changes, atCommit);
+      if (pending <= symbolBudget) {
+        symbolBudget -= pending;
+        changes = await (0, import_workstream_symbols.withSymbolChanges)(repo, b.changes, symbolParser, atCommit);
+      } else {
+        later.push({ folder: repo, changes: b.changes, atCommit });
+      }
+    }
+    out.push({
+      root: `branch:${b.short}`,
+      ref: b.ref,
+      branch: b.short,
+      head: b.head,
+      main: false,
+      shape: "branch",
+      agents: [],
+      changes,
+      idle: b.changes.files.length === 0
+    });
+  }
+  warmSymbols(repo, repo, later);
+  return out;
+}
+const INLINE_SYMBOL_FILES = 60;
+const symbolWarming = /* @__PURE__ */ new Map();
+function branchSymbolsWarmed(repo) {
+  return Promise.all([symbolWarming.get(repo), symbolWarming.get(`${repo}\0trees`)]).then(() => void 0);
+}
+function warmSymbols(key, repo, jobs) {
+  if (!symbolParser || jobs.length === 0 || symbolWarming.has(key)) return;
+  const parse = symbolParser;
+  const run = (async () => {
+    await new Promise((resolve) => setImmediate(resolve));
+    for (const j of jobs) await (0, import_workstream_symbols.withSymbolChanges)(j.folder, j.changes, parse, j.atCommit).catch(() => void 0);
+  })().finally(() => {
+    symbolWarming.delete(key);
+    (0, import_branch_workstreams.notifyBranchesWarmed)(repo);
+  });
+  symbolWarming.set(key, run);
+}
+const canonicalPath = (p) => {
+  try {
+    return import_node_fs.default.realpathSync.native(p);
+  } catch {
+    return p;
+  }
+};
+async function cloneTrees(projectRoot, worktrees) {
+  const origin = (0, import_recent_projects_service.getRecentProject)(projectRoot)?.originUrl ?? null;
+  if (!origin) return [];
+  const own = new Set(worktrees.map((w) => canonicalPath(w.path)));
+  own.add(canonicalPath(projectRoot));
+  const out = [];
+  for (const root of (0, import_trusted_roots.listTrustedRoots)()) {
+    if (own.has(canonicalPath(root))) continue;
+    if ((0, import_recent_projects_service.getRecentProject)(root)?.originUrl !== origin) continue;
+    const self = (await (0, import_worktree_service.listWorktreesAsync)(root)).find((w) => w.isMain);
+    out.push({ path: root, branch: self?.branch ?? null, head: self?.head ?? null, isMain: false, isCurrent: false, bare: false, prunable: false });
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INLINE_SYMBOL_FILES,
+  MAX_WATCHED_TREES,
+  branchSymbolsWarmed,
+  deriveWorkstreams,
+  discoverAround,
+  getSymbolParser,
+  listWorkstreamPlaces,
+  listWorkstreams,
+  setClaudeSessionSource,
+  setSymbolParser,
+  treesToWatch,
+  workstreamBranches
+});