@staix/agent-hub 0.12.45 → 0.13.0

package/src/hub/settings.ts

@@ -1,3 +1,4 @@
+import { ACTION_CLASSES } from "./action-class.ts";
 import { definitionOf, type KindMap, type ProjectAdapterCatalog, ADAPTERS, PLANNER_PEERS, SUPPORTED_PEERS, START_MODE_PEERS } from "../adapters/registry.ts";
 import { createHash } from "node:crypto";
 import { types } from "node:util";
@@ -59,6 +60,8 @@ export const SETTINGS: readonly SettingDef[] = [
   ...SETTING_PEERS.map((peer): SettingDef => ({ key: `catalog_roles.${peer}`, group: "Roles", label: `${peer}: catalog guidance`, type: "roles", store: "config", applies: "next use", risk: "safe", path: ["catalog_roles", peer] })),
   { key: "scoped_grants.protect_instructions", group: "Permissions", label: "Ask before writing instruction files", type: "boolean", store: "config", applies: "live", risk: "raises", floor: true, path: ["protect_instruction_files"] },
   ...SETTING_PEERS.map((peer): SettingDef => ({ key: `roster.${peer}`, group: "Roster", label: `${peer}: participates`, type: "boolean", store: "config", applies: "live", risk: "raises", floor: false, path: ["roster", peer] })),
+  { key: "action_policy.enabled", group: "Permissions", label: "Always-ask action policy", type: "boolean", store: "config", applies: "live", risk: "raises", floor: true, path: ["action_policy", "enabled"] },
+  ...ACTION_CLASSES.map((kind): SettingDef => ({ key: `action_policy.budgets.${kind}`, group: "Permissions", label: `${kind}: approved session budget`, type: "integer", min: 0, max: 1000, store: "config", applies: "live", risk: "raises", floor: 0, path: ["action_policy", "budgets", kind] })),
   ...SETTING_PEERS.filter(peer => !definitionOf(peer)?.permission.unmanaged).map((peer): SettingDef => ({ key: `permission.${peer}`, group: "Permissions", label: `${peer}: mode now`, type: "enum", values: PERMISSION_MODES, store: "runtime", applies: "live", risk: "raises", floor: "ask", path: [peer] })),
   ...SETTING_PEERS.filter(peer => !definitionOf(peer)?.permission.unmanaged).map((peer): SettingDef => ({ key: `permission_modes.${peer}`, group: "Permissions", label: `${peer}: mode at next peer start`, type: "enum", values: PERMISSION_MODES, store: "config", applies: "next use", risk: "raises", floor: "ask", path: ["permission_modes", peer] })),
   ...START_MODE_PEERS.map((peer): SettingDef => ({ key: `peers.${peer}.start_mode`, group: "Start", label: `${peer}: start mode (tui unless set)`, type: "enum", values: START_MODES, store: "config", applies: "next use", risk: "raises", floor: "tui", path: ["peers", peer, "start_mode"] })),
@@ -470,7 +473,7 @@ export function settingRows(input: {
   const scalar = (value: unknown): SettingValue => typeof value === "string" || typeof value === "boolean" || typeof value === "number" ? value : Array.isArray(value) ? value.map(String) : null;
   return projectSettings(input.instances, input.adapterCatalog).map((def): SettingRow => {
     const base = { key: def.key, group: def.group, label: def.label, type: def.type, ...(["integer", "number"].includes(def.type) ? { min: def.min, max: def.max } : {}), applies: def.applies, ...(def.restartReason ? { restartReason: def.restartReason } : {}), risk: def.risk, ...(def.floor === undefined ? {} : { floor: def.floor }),
-      ...(def.key === "scoped_grants.protect_instructions" ? { hint: "AGENTS.md, CLAUDE.md and QWEN.md remain grantable by default; enabling this asks before scoped writes and edits" } : def.group === "Permissions" ? { hint: permissionBoundary(def.path.at(-1)!, input.instances, input.adapterCatalog) } : {}) };
+      ...(def.key === "scoped_grants.protect_instructions" ? { hint: "AGENTS.md, CLAUDE.md and QWEN.md remain grantable by default; enabling this asks before scoped writes and edits" } : def.key.startsWith("action_policy.") ? { hint: "not enforced yet: adapter integration pending" } : def.group === "Permissions" ? { hint: permissionBoundary(def.path.at(-1)!, input.instances, input.adapterCatalog) } : {}) };
     if (def.locked) return { ...base, values: def.values, file: def.store === "runtime" ? "this hub run" : CONFIG_LOCAL,
       source: "instance declaration", value: "read-only", fileValue: "read-only", locked: def.locked, note: def.locked };
     if (def.store === "runtime") {
@@ -485,7 +488,7 @@ export function settingRows(input: {
     if (def.type === "roles" && input.roles) { const roles = input.roles(def.path[1]!); return { ...base, ...roles, fileValue: roles.pending !== undefined ? roles.pending : roles.value, file: CONFIG_LOCAL, source: valueAt(local, def.path) !== undefined ? CONFIG_LOCAL : valueAt(shared, def.path) !== undefined ? "config.json" : "profile/default", hint: "Guidance only; grants no tool or permission. At most two roles, applied at the next peer start." }; }
     const value = scalar(input.running(def.path));
     const stored = input.next ? scalar(input.next(def.path)) : value;
-    const source = valueAt(local, def.path) !== undefined ? CONFIG_LOCAL : valueAt(shared, def.path) !== undefined ? "config.json" : "default";
+    const source = valueAt(local, def.path) !== undefined ? CONFIG_LOCAL : !def.key.startsWith("action_policy.") && valueAt(shared, def.path) !== undefined ? "config.json" : "default";
     const dropped = ignoredLine(input.ignored, def);
     return { ...base, ...(def.values ? { values: def.values } : {}), file: CONFIG_LOCAL, value, fileValue: stored, source, ...(same(value, stored) ? {} : { pending: stored }),
       ...(!input.next ? { note: "the config files do not load; fix them in your editor" } : dropped ? { note: `the hub does not read this value: ${dropped}` } : {}) };

package/src/hub/snapshots.ts

@@ -26,12 +26,13 @@ export const budgetNow = (budget: SnapshotBudget): number => budget.now ? budget
 export class SnapshotBudgetExceeded extends Error {
   constructor() { super("snapshot burst budget exhausted; boundary evidence is unknown"); }
 }
-const git = (top: string | Repo, args: string[], env: Record<string, string> = {}, budget?: SnapshotBudget, maxBuffer?: number) => {
+const git = (top: string | Repo, args: string[], env: Record<string, string> = {}, budget?: SnapshotBudget, maxBuffer?: number, input?: string | Buffer) => {
   const argv = repoGitArgs(top, args);
   const remaining = budget ? budget.deadline - budgetNow(budget) : SNAPSHOT_TIMEOUT_MS;
   if (remaining <= 0) throw new SnapshotBudgetExceeded();
   const result = hubGitSync(argv, {
     encoding: "utf8", env: { ...repoGitEnv(top), ...env }, ...(maxBuffer === undefined ? {} : { maxBuffer }),
+    ...(input === undefined ? {} : { input }),
     timeout: Math.max(1, Math.min(SNAPSHOT_TIMEOUT_MS, Math.floor(remaining))),
   });
   if (budget && (budgetNow(budget) >= budget.deadline || (result.error as NodeJS.ErrnoException | undefined)?.code === "ETIMEDOUT")) throw new SnapshotBudgetExceeded();
@@ -311,11 +312,81 @@ export function incomingHeadPaths(repo: Repo, start: HeadMoveCursor, end: HeadMo
   if (appended[appended.length - 1] !== 10) return undefined;
   const lines = appended.toString("utf8").slice(0, -1).split("\n");
   if (lines.length > HEAD_LOG_MAX_MOVES) return undefined;
+
+  const diffCache = new Map<string, string[] | undefined>();
+  const ancestorCache = new Map<string, boolean>();
+  const diffOf = (from: string, to: string): string[] | undefined => {
+    if (from === to) return [];
+    const key = `${from}..${to}`;
+    if (diffCache.has(key)) return diffCache.get(key);
+    const res = knownChangedPaths(repo, from, to, budget);
+    diffCache.set(key, res);
+    return res;
+  };
+  const isAncestor = (oldCommit: string, nextCommit: string): boolean => {
+    if (oldCommit === nextCommit) return true;
+    const key = `${oldCommit}..${nextCommit}`;
+    if (ancestorCache.has(key)) return ancestorCache.get(key)!;
+    const ancestor = git(repo, ["merge-base", "--is-ancestor", oldCommit, nextCommit], {}, budget);
+    const ok = ancestor.status === 0;
+    ancestorCache.set(key, ok);
+    return ok;
+  };
+
+  const parsedRows: Array<ReturnType<typeof headLogRow>> = [];
+  const batchCandidates = new Set<string>();
+  for (const line of lines) {
+    const row = headLogRow(line);
+    parsedRows.push(row);
+    if (!row) continue;
+    const separator = row.action.indexOf(": ");
+    const action = separator < 0 ? "" : row.action.slice(0, separator);
+    // #612: diff-tree --stdin compares a commit to its first parent. In git sequencer, only pick
+    // and initial/regular commits have row.old as the parent of row.next. Sequencer squash, fixup,
+    // reword and edit amend the commit, so row.next's parent is row.old's parent. Only batch rows
+    // where row.old is the parent (pick and commit); other rows are diffed individually.
+    const isPickOrCommit = /^.+ \(pick\)$/.test(action) || action === "commit";
+    if (isPickOrCommit && row.old !== row.next && !/^0+$/.test(row.old)) {
+      batchCandidates.add(row.next);
+    }
+  }
+
+  // Batch single-parent pick/commit diffs across the boundary to stay within burst budget (#612).
+  if (batchCandidates.size > 1) {
+    const commitList = [...batchCandidates];
+    const stdinInput = commitList.join("\n") + "\n";
+    const batchRes = git(repo, ["diff-tree", "--stdin", "--always", "-r", "--no-renames", "--raw", "-z", "--", scope(repo)], {}, budget, undefined, stdinInput);
+    if (batchRes.status === 0) {
+      const parts = batchRes.stdout.split("\0");
+      if (parts.length && parts[parts.length - 1] === "") parts.pop();
+      let i = 0;
+      while (i < parts.length) {
+        const commit = parts[i++];
+        if (!commit) continue;
+        const paths: string[] = [];
+        while (i < parts.length && parts[i]?.startsWith(":")) {
+          i++; // skip raw metadata: :oldmode newmode oldsha newsha status
+          if (i < parts.length && parts[i]) {
+            paths.push(parts[i++]!);
+          }
+        }
+        for (const r of parsedRows) {
+          if (r && r.next === commit && r.old !== r.next) {
+            const sep = r.action.indexOf(": ");
+            const act = sep < 0 ? "" : r.action.slice(0, sep);
+            if (/^.+ \(pick\)$/.test(act) || act === "commit") {
+              diffCache.set(`${r.old}..${r.next}`, [...paths]);
+            }
+          }
+        }
+      }
+    }
+  }
+
   const own = new Set<string>(), incoming = new Set<string>();
   let previous = start.head;
-  for (const line of lines) {
+  for (const row of parsedRows) {
     checkSnapshotBudget(budget);
-    const row = headLogRow(line);
     if (!row || (previous === null ? !/^0+$/.test(row.old) : row.old !== previous)) return undefined;
     // Git preserves the invoking command in sequencer actions (for example pull -q --rebase (pick)).
     // Classify the native phase before considering ordinary command-shaped incoming actions.
@@ -328,10 +399,11 @@ export function incomingHeadPaths(repo: Repo, start: HeadMoveCursor, end: HeadMo
     const incomingCommand = !action.includes("(") && /^(?:merge|pull)(?: [^:]+)?$/.test(action) && !!detail;
     let incomingMove = !ownMove && (incomingStart || incomingCommand || action === "checkout" && /^moving from .+ to .+$/.test(detail));
     if (action === "reset" && /^moving to .+/.test(detail)) {
-      // Policy: a positively fast-forward reset is incoming, even when its target contains the peer's own
-      // descendant commit; reflog ancestry alone cannot distinguish that intent. Rewinds/unknown resets refuse.
-      const ancestor = git(repo, ["merge-base", "--is-ancestor", row.old, row.next], {}, budget);
-      if (ancestor.status !== 0) return undefined;
+      // Policy: a positively fast-forward reset stays incoming, even when its target contains the peer's own
+      // descendant commit made in another worktree during the turn. Reflog ancestry alone cannot distinguish
+      // local worktree coordination from external branch fast-forwards; classifying it as incoming safely
+      // excludes external commits from local turn attribution and undo. Rewinds/unknown resets refuse.
+      if (!isAncestor(row.old, row.next)) return undefined;
       incomingMove = true;
     }
     if (!ownMove && !incomingMove) return undefined;
@@ -339,7 +411,19 @@ export function incomingHeadPaths(repo: Repo, start: HeadMoveCursor, end: HeadMo
     if (/^0+$/.test(row.old)) {
       const root = git(repo, ["diff-tree", "--root", "--no-commit-id", "-r", "--no-renames", "--name-only", "-z", row.next, "--", scope(repo)], {}, budget);
       paths = root.status === 0 ? root.stdout.split("\0").filter(Boolean) : undefined;
-    } else paths = knownChangedPaths(repo, row.old, row.next, budget);
+    } else if (incomingStart) {
+      // #612: take incoming start paths as merge-base(old, upstream)..upstream instead of old..upstream,
+      // so the peer's replayed own commits do not overlap and only true upstream paths are excluded.
+      // Any remaining ambiguity (no merge base, criss-cross multiple merge bases) stays unknown.
+      const mb = git(repo, ["merge-base", "--all", row.old, row.next], {}, budget);
+      if (mb.status !== 0) return undefined;
+      const bases = mb.stdout.trim().split("\n").map(s => s.trim()).filter(Boolean);
+      const base = bases[0];
+      if (bases.length !== 1 || !base || !/^[0-9a-f]{40,64}$/.test(base)) return undefined;
+      paths = base === row.next ? [] : diffOf(base, row.next);
+    } else {
+      paths = diffOf(row.old, row.next);
+    }
     if (!paths) return undefined;
     for (const path of paths) { checkSnapshotBudget(budget); (ownMove ? own : incoming).add(path); }
     previous = row.next;
@@ -394,6 +478,7 @@ export function snapshot(repo: Repo, budget?: SnapshotBudget): string | undefine
 
 /** Project paths (relative to the top level) that differ between two trees. */
 export function knownChangedPaths(repo: Repo, from: string, to: string, budget?: SnapshotBudget): string[] | undefined {
+  if (from === to) return [];
   const r = git(repo, ["diff-tree", "-r", "--no-renames", "--name-only", "-z", from, to, "--", scope(repo)], {}, budget);
   return r.status === 0 ? r.stdout.split("\0").filter(Boolean) : undefined;
 }

package/src/hub/symbol-normalizer.ts

@@ -0,0 +1,26 @@
+/**
+ * Strip parentheses and arguments from a plan symbol name.
+ * Section and source keys (`section ...`, `source ...`) are preserved unchanged.
+ */
+export function normalizePlanSymbol(name: string): string {
+  if (typeof name !== "string") return "";
+  if (name.startsWith("section ") || name.startsWith("source ")) return name;
+  return name.replace(/\s*\(.*$/, "").trim();
+}
+
+/**
+ * Compare two plan symbols for overlap (#682 phase 1b).
+ * - Section and source keys must match exactly.
+ * - Otherwise, names are compared by their last segment; when both names are qualified
+ *   (e.g. `A.run` vs `B.run`), the qualifiers must match as well.
+ */
+export function symbolsOverlap(left: string, right: string): boolean {
+  if (typeof left !== "string" || typeof right !== "string") return false;
+  if (left.startsWith("section ") || left.startsWith("source ") || right.startsWith("section ") || right.startsWith("source ")) {
+    return left === right;
+  }
+  const a = normalizePlanSymbol(left);
+  const b = normalizePlanSymbol(right);
+  if (!a || !b) return false;
+  return a.includes(".") && b.includes(".") ? a === b : a.split(".").at(-1) === b.split(".").at(-1);
+}

package/src/hub/task-code-symbols.ts

@@ -0,0 +1,90 @@
+import type { ReviewBrief } from "./review-brief.ts";
+
+export interface TaskCodeSymbol { id: string; path: string; name: string; kind: string }
+export interface TaskCodeSymbols {
+  head: string; mergeBase: string; repositoryKey: string;
+  state: "known" | "unknown"; complete: boolean; countsFloor: true; symbols: TaskCodeSymbol[];
+}
+export const HOST_CODE_SYMBOLS = Symbol("host task code symbols");
+const sha = (value: unknown): value is string => typeof value === "string" && /^[a-f0-9]{40}$/.test(value);
+const text = (value: unknown): value is string => typeof value === "string" && value.length > 0 && Buffer.byteLength(value) <= 512 && !/[\p{Cc}\p{Cf}]/u.test(value);
+const path = (value: unknown): value is string => text(value) && !value.startsWith("/") && !value.includes("\\") && !value.split("/").some(part => !part || part === "." || part === ".." || part.toLowerCase() === ".git");
+const object = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value) && [Object.prototype, null].includes(Object.getPrototypeOf(value));
+const bounded = (value: unknown) => Buffer.byteLength(JSON.stringify(value)) <= 64 * 1024;
+
+/** Stored observations are host-derived metadata, not code or caller-provided spans. */
+export function parseTaskCodeSymbols(value: unknown): TaskCodeSymbols | undefined {
+  try {
+    if (!object(value) || !sha(value.head) || !sha(value.mergeBase) || !text(value.repositoryKey)
+      || (value.state !== "known" && value.state !== "unknown") || typeof value.complete !== "boolean" || value.countsFloor !== true
+      || !Array.isArray(value.symbols) || value.symbols.length > 500 || !bounded(value)) return;
+    const symbols: TaskCodeSymbol[] = [], ids = new Set<string>();
+    for (const item of value.symbols) {
+      if (!object(item) || !text(item.id) || !path(item.path) || !text(item.name) || !text(item.kind)
+        || !/^[a-z_]+$/.test(item.kind) || item.id !== `symbol:${item.name}@${item.path}` || ids.has(item.id)) return;
+      ids.add(item.id); symbols.push({ id: item.id, path: item.path, name: item.name, kind: item.kind });
+    }
+    if (value.state === "unknown" && (value.complete || symbols.length)) return;
+    return { head: value.head, mergeBase: value.mergeBase, repositoryKey: value.repositoryKey, state: value.state as "known" | "unknown", complete: value.complete, countsFloor: true, symbols };
+  } catch { return; }
+}
+
+/** Caller must certify that the earlier preparation did not filter or truncate any symbols. */
+export function buildTaskCodeSymbols(brief: ReviewBrief | undefined, repositoryKey: string, screen: (text: string) => boolean, privateTask = false): TaskCodeSymbols | undefined {
+  if (privateTask || !brief || !sha(brief.head) || !sha(brief.mergeBase) || !text(repositoryKey)) return;
+  const unknown: TaskCodeSymbols = { head: brief.head, mergeBase: brief.mergeBase, repositoryKey, state: "unknown", complete: false, countsFloor: true, symbols: [] };
+  try {
+    if (brief.symbols?.state !== "known") return unknown;
+    if (!Array.isArray(brief.symbols.files) || brief.symbols.files.length > 500 || !Array.isArray(brief.reviewable) || brief.reviewable.length > 500) return unknown;
+    const reviewable = new Set(brief.reviewable.map(file => file.path)), files = new Set<string>();
+    if ([...reviewable].some(value => !path(value))) return unknown;
+    let complete = brief.symbols.complete === true && brief.withheld === 0 && brief.unlisted.length === 0;
+    const symbols: TaskCodeSymbol[] = [], ids = new Set<string>();
+    let observed = 0;
+    for (const file of brief.symbols.files) {
+      if (!path(file.path) || !reviewable.has(file.path) || files.has(file.path) || !Array.isArray(file.symbols)) return unknown;
+      files.add(file.path);
+      for (const symbol of file.symbols) {
+        if (++observed > 500) return unknown;
+        const id = `symbol:${symbol.name}@${file.path}`;
+        if (symbol.ambiguous || symbol.path !== file.path || !text(symbol.name) || !text(symbol.kind) || !/^[a-z_]+$/.test(symbol.kind)
+          || !text(id) || !screen(file.path) || !screen(symbol.name) || !screen(symbol.kind) || !screen(id)) { complete = false; continue; }
+        if (ids.has(id)) { complete = false; continue; }
+        ids.add(id); symbols.push({ id, path: file.path, name: symbol.name, kind: symbol.kind });
+      }
+    }
+    if (files.size !== reviewable.size) complete = false;
+    const result: TaskCodeSymbols = { ...unknown, state: "known", complete, symbols };
+    return bounded(result) ? result : unknown;
+  } catch { return unknown; }
+}
+
+/** Re-screen every public read; repository place keys are internal and never exported. */
+export function publicTaskCodeSymbols(receipt: TaskCodeSymbols | undefined, head: string | undefined, repositoryKey: string, screen: (text: string) => boolean, privateTask = false): Omit<TaskCodeSymbols, "repositoryKey"> | undefined {
+  const valid = parseTaskCodeSymbols(receipt);
+  if (privateTask || !valid || !sha(head) || valid.head !== head || valid.repositoryKey !== repositoryKey) return;
+  let complete = valid.complete;
+  const symbols = valid.symbols.filter(symbol => {
+    try { if ([symbol.id, symbol.path, symbol.name, symbol.kind].every(value => screen(value))) return true; } catch { /* failed policy is withheld */ }
+    complete = false; return false;
+  });
+  const { repositoryKey: _repositoryKey, ...result } = valid;
+  return { ...result, complete, symbols };
+}
+
+/** Advisory observed disjointness only. Floors/deleted-symbol limitations never justify a gate or lost notice. */
+export function taskCodeSymbolsDisjoint(left: TaskCodeSymbols | undefined, right: TaskCodeSymbols | undefined, leftHead: string | undefined, rightHead: string | undefined, repositoryKey: string, sharedPaths: readonly string[], privateData = false, screen?: (text: string) => boolean): boolean {
+  const current = (receipt: TaskCodeSymbols | undefined, head: string | undefined) => {
+    if (!screen) return parseTaskCodeSymbols(receipt);
+    const projected = publicTaskCodeSymbols(receipt, head, repositoryKey, screen, privateData);
+    return projected ? { ...projected, repositoryKey } : undefined;
+  };
+  const a = current(left, leftHead), b = current(right, rightHead);
+  if (privateData || !a || !b || !sha(leftHead) || !sha(rightHead) || a.head !== leftHead || b.head !== rightHead
+    || a.repositoryKey !== repositoryKey || b.repositoryKey !== repositoryKey || a.state !== "known" || b.state !== "known" || !a.complete || !b.complete
+    || !sharedPaths.length || sharedPaths.length > 500 || sharedPaths.some(value => !path(value))) return false;
+  return sharedPaths.every(file => {
+    const xs = a.symbols.filter(s => s.path === file), ys = b.symbols.filter(s => s.path === file);
+    return xs.length > 0 && ys.length > 0 && !xs.some(x => ys.some(y => x.id === y.id || (!x.name.includes(".") && y.name.endsWith(`.${x.name}`)) || (!y.name.includes(".") && x.name.endsWith(`.${y.name}`))));
+  });
+}

package/src/hub/task-sweep.ts

@@ -1,4 +1,5 @@
 import type { Task } from "./board.ts";
+import { normalizePlanSymbol, symbolsOverlap } from "./symbol-normalizer.ts";
 
 export type SweepKind = "unaccepted-assignment" | "idle-owner" | "review-pending" | "ready-unassigned";
 export interface SweepRecord {
@@ -187,7 +188,7 @@ export function plannerGrooming(tasks: readonly Task[], options: PlannerGrooming
       if (!reviewed && !accepted) unknown.add(task.id);
     }
   }
-  const places = (task: Task) => ({ paths: new Set([...(task.refs.paths ?? []), ...(task.plan?.paths ?? [])].map(groomingPath).filter((path): path is string => path !== undefined)), symbols: new Set(task.plan?.symbols ?? []) });
+  const places = (task: Task) => ({ paths: new Set([...(task.refs.paths ?? []), ...(task.plan?.paths ?? [])].map(groomingPath).filter((path): path is string => path !== undefined)), symbols: new Set((task.plan?.symbols ?? []).map(normalizePlanSymbol)) });
   const open = scoped.filter(task => task.state !== "cancelled");
   const positions = new Map(open.map(task => [task.id, places(task)]));
   const overlaps = (left: string, right: string): boolean => left === right || left === "." || right === "."
@@ -196,7 +197,7 @@ export function plannerGrooming(tasks: readonly Task[], options: PlannerGrooming
     const task = open[left]!;
     if (repositories.get(task.id) !== repositories.get(right.id)) continue;
     const a = positions.get(task.id)!, b = positions.get(right.id)!;
-    if ([...a.paths].some(path => [...b.paths].some(other => overlaps(path, other))) || [...a.symbols].some(symbol => b.symbols.has(symbol))) add({ kind: "overlap", task: task.id, related: [right.id] });
+    if ([...a.paths].some(path => [...b.paths].some(other => overlaps(path, other))) || [...a.symbols].some(symbol => [...b.symbols].some(other => symbolsOverlap(symbol, other)))) add({ kind: "overlap", task: task.id, related: [right.id] });
     if ([...issueIds.get(task.id)!].some(issue => issueIds.get(right.id)!.has(issue))) add({ kind: "duplicate", task: task.id, related: [right.id] });
   }
   for (const blocker of (options.blockers ?? []).slice(0, GROOMING_TASK_LIMIT)) {