@staix/agent-hub 0.12.45 → 0.14.0

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/spec-read.ts

@@ -48,6 +48,37 @@ export function specRefs(task: Pick<Task, "title" | "detail" | "refs"> & Partial
   return [...issues];
 }
 
+/**
+ * #723: issue numbers a title names as a sibling repository (`agent-mem#13`) when the task's `refs.repo` is that repository.
+ * The bare name must equal the repository part of `refs.repo`; nothing else is guessed, and nothing is read. A bare
+ * `#N` and an `owner/repo#N` form are specRefs' business, never this function's.
+ */
+export function siblingTitleRefs(title: string, repo: string | undefined): number[] {
+  if (!repo || !isGitHubRepository(repo)) return [];
+  const name = repo.split("/")[1]!.toLowerCase(), found = new Set<number>();
+  for (const match of title.matchAll(/(?<![A-Za-z0-9_./-])([A-Za-z0-9_.-]+)#([1-9][0-9]*)\b/g)) {
+    if (match[1]!.toLowerCase() === name) found.add(Number(match[2]));
+  }
+  return [...found].slice(0, 4);
+}
+
+/** Words that precede `#N` without naming a repository (`PR#12`); never worth a refs.repo suggestion. */
+const NOT_A_REPOSITORY = new Set(["pr", "pull", "issue", "issues", "task", "tasks", "bug", "fix", "phase", "step", "item", "ticket", "gh", "id", "no", "nr", "p", "s", "t", "u"]);
+/**
+ * #723: the qualified repository names a title carries (`owner/repo#N` as `owner/repo`, `agent-mem#13` as `agent-mem`), so
+ * propose can suggest `refs.repo`. Advice only: a hit is a hint, never an identity.
+ */
+export function qualifiedTitleRepos(title: string): string[] {
+  const found = new Set<string>();
+  for (const match of title.matchAll(/(?<![A-Za-z0-9_./-])(?:([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+)|([A-Za-z0-9_.-]*[A-Za-z][A-Za-z0-9_.-]*))#[1-9][0-9]*\b/g)) {
+    const name = match[1] ?? match[2]!;
+    if (match[1] ? !isGitHubRepository(name) : NOT_A_REPOSITORY.has(name.toLowerCase())) continue;
+    found.add(name);
+    if (found.size >= 4) break;
+  }
+  return [...found];
+}
+
 interface GhResult { code: number; stdout: string; }
 /** One fixed-argv authenticated boundary, no shell, no retries and no retained stderr. */
 function gh(args: string[], opts: SpecOptions): Promise<GhResult> {

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-group.ts

@@ -0,0 +1,52 @@
+import { symbolsOverlap } from "./symbol-normalizer.ts";
+
+// #684 2c: the dashboard task sheet's "Code" group, classified on the hub so the page never matches names itself. Pure data in, ids and
+// names out. The observation (`codeSymbols`) is the receipt `Tasks.publicView` already re-screened; the plan names are `plan.symbols`, the same
+// list the review brief reads as `planned`. Advisory only: ripwire does not report deleted symbols, so neither list proves a plan was followed.
+
+export interface CodeGroupSymbol { id: string; name: string; path: string; kind: string; mark: "matching" | "unplanned" }
+export interface CodeGroup {
+  state: "known" | "unknown";
+  complete: boolean;
+  head?: string;
+  symbols: CodeGroupSymbol[];
+  /** Plan names nothing changed under. */
+  untouched: string[];
+  /** How many more changed symbols exist than are listed, so a cap is never read as the whole. */
+  more: number;
+  /** Totals before the cap, so the sheet's counts are the whole and not the listed part. */
+  counts: { matching: number; unplanned: number; untouched: number };
+  /** Plan names the hub would not show (screened out or malformed). While any is withheld a symbol marked unplanned may be planned, and one marked untouched may not be. */
+  planWithheld: number;
+}
+
+export const CODE_GROUP_MAX = 40;
+/** The stored plan's own bounds (`cleanPlan`: 300 characters a name, 50 names), so no stored name is dropped for its length alone. */
+export const PLAN_NAME_MAX = 300, PLAN_NAMES_MAX = 50;
+interface Receipt { state?: unknown; complete?: unknown; head?: unknown; symbols?: unknown }
+const word = (value: unknown, max: number): value is string => typeof value === "string" && value.length > 0 && value.length <= max && !/[\p{Cc}\p{Cf}]/u.test(value);
+
+/**
+ * `receipt` is the public `codeSymbols` (never the stored one, which carries `repositoryKey`); `plan` the task's `plan.symbols`; `screen`
+ * the hub's `publicMetadataText`. Returns undefined for a private task: the sheet then shows no Code group at all.
+ */
+export function codeGroup(task: { id: number }, receipt: unknown, plan: unknown, screen: (text: string) => boolean, privateTask: boolean): CodeGroup | undefined {
+  if (privateTask) return undefined;
+  const r = (receipt && typeof receipt === "object" && !Array.isArray(receipt) ? receipt : undefined) as Receipt | undefined;
+  if (!r || r.state !== "known" || !Array.isArray(r.symbols) || Object.hasOwn(r, "repositoryKey")) return { state: "unknown", complete: false, symbols: [], untouched: [], more: 0, counts: { matching: 0, unplanned: 0, untouched: 0 }, planWithheld: 0 };
+  // Every stored plan name is read; one that is malformed or fails the screen is counted, never silently dropped, because dropping it would
+  // turn a symbol the plan names into an "unplanned" one and the sheet would show a departure that never happened.
+  const given = Array.isArray(plan) ? plan.slice(0, PLAN_NAMES_MAX + 1) : [];
+  const planned = given.slice(0, PLAN_NAMES_MAX).filter((name): name is string => word(name, PLAN_NAME_MAX)).filter(name => { try { return screen(name); } catch { return false; } });
+  const planWithheld = (given.length > PLAN_NAMES_MAX ? given.length - PLAN_NAMES_MAX : 0) + (Math.min(given.length, PLAN_NAMES_MAX) - planned.length);
+  const changed: CodeGroupSymbol[] = [];
+  for (const item of r.symbols as Record<string, unknown>[]) {
+    if (!item || !word(item.id, 512) || !word(item.name, 512) || !word(item.path, 512) || !word(item.kind, 64) || item.id !== `symbol:${item.name}@${item.path}`) continue;
+    changed.push({ id: item.id, name: item.name, path: item.path, kind: item.kind, mark: planned.some(name => symbolsOverlap(name, item.name as string)) ? "matching" : "unplanned" });
+  }
+  const untouched = planned.filter(name => !changed.some(symbol => symbolsOverlap(name, symbol.name)));
+  const shown = changed.slice(0, CODE_GROUP_MAX);
+  return { state: "known", complete: r.complete === true && changed.length === r.symbols.length && planWithheld === 0, ...(typeof r.head === "string" && /^[a-f0-9]{40}$/.test(r.head) ? { head: r.head.slice(0, 8) } : {}),
+    symbols: shown, untouched: untouched.slice(0, CODE_GROUP_MAX), more: Math.max(0, changed.length - shown.length) + Math.max(0, untouched.length - CODE_GROUP_MAX),
+    counts: { matching: changed.filter(s => s.mark === "matching").length, unplanned: changed.filter(s => s.mark === "unplanned").length, untouched: untouched.length }, planWithheld };
+}

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)) {