@mandipadk7/kavi 0.1.4 → 0.1.6

package/README.md

@@ -10,14 +10,16 @@ Current capabilities:
 - `kavi start`: start a managed session without attaching the TUI.
 - `kavi open`: create a managed session with separate Codex and Claude worktrees and open the full-screen operator console, even from an empty folder or a repo with no `HEAD` yet.
 - `kavi resume`: reopen the operator console for the current repo session.
-- `kavi status`: inspect session health and task counts from any terminal.
+- `kavi status`: inspect session health, task counts, and configured routing ownership rules from any terminal.
+- `kavi route`: preview how Kavi would route a prompt before enqueuing it.
+- `kavi routes`: inspect recent task routing decisions with strategy, confidence, and metadata.
 - `kavi paths`: inspect resolved repo-local, user-local, worktree, and runtime paths.
 - `kavi task`: enqueue a task for `codex`, `claude`, or `auto` routing.
 - `kavi tasks`: inspect the session task list with summaries and artifact availability.
 - `kavi task-output`: inspect the normalized envelope and raw output for a completed task.
 - `kavi decisions`: inspect the persisted routing, approval, task, and integration decisions.
 - `kavi claims`: inspect active or historical path claims.
-- `kavi reviews`: inspect persisted operator review threads and linked follow-up tasks.
+- `kavi reviews`: inspect persisted operator review threads and linked follow-up tasks, with filters for agent, assignee, disposition, and status.
 - `kavi approvals`: inspect the approval inbox.
 - `kavi approve` and `kavi deny`: resolve a pending approval request, optionally with `--remember`.
 - `kavi events`: inspect recent daemon and task events.
@@ -33,15 +35,21 @@ Runtime model:
 - SQLite event mirroring is opt-in with `KAVI_ENABLE_SQLITE_HISTORY=1`; the default event log is JSONL under `.kavi/state/events.jsonl`.
 - The operator console exposes a task board, dual agent lanes, a live inspector pane, approval actions, inline task composition, worktree diff review with file and hunk navigation, and persisted operator review threads on files or hunks.
 - Routing can now use explicit path ownership rules from `.kavi/config.toml` via `[routing].codex_paths` and `[routing].claude_paths`, so known parts of the tree can bypass looser keyword or AI routing.
+- Ownership routing now prefers the strongest matching rule, not just the side with the most raw glob hits, and route metadata records the winning rule when one exists.
+- Diff-based path claims now release older overlapping same-agent claims automatically, so the active claim set stays closer to each managed worktree's current unlanded surface.
 
 Notes:
 - `kavi init` and `kavi open` now support the "empty folder to first managed session" path. If no git repo exists, Kavi initializes one; if git exists but no `HEAD` exists yet, Kavi creates the bootstrap commit it needs for worktrees.
 - Codex runs through `codex app-server` in managed mode, so Codex-side approvals now land in the same Kavi inbox as Claude hook approvals.
 - Claude still runs through the installed `claude` CLI with Kavi-managed hooks and approval decisions.
 - `kavi doctor` now checks Claude auth readiness with `claude auth status`, and startup blocks if Claude is installed but not authenticated.
+- `kavi doctor` also validates ownership path rules for duplicates, repo escapes, and absolute-path mistakes before those rules affect routing.
+- `kavi doctor` now also flags overlapping cross-agent ownership rules that do not produce a clear specificity winner.
 - The dashboard and operator commands now use the daemon's local RPC socket instead of editing session files directly, and the TUI stays updated from pushed daemon snapshots rather than polling.
 - The socket is machine-local rather than repo-local to avoid Unix socket path-length issues in deep repos and temp directories.
-- The console is keyboard-driven: `1-7` switch views, `j/k` move selection, `[` and `]` cycle task detail sections, `,` and `.` cycle changed files, `{` and `}` cycle patch hunks, `A/C/Q/M` add review notes, `o/O` cycle existing threads, `T` reply, `E` edit, `R` resolve or reopen, `a` cycle thread assignee, `w` mark a thread as won't-fix, `x` mark it as accepted-risk, `F` queue a fix task, `H` queue a handoff task, `y/n` resolve approvals, and `c` opens the inline task composer.
+- The console is keyboard-driven: `1-7` switch views, `j/k` move selection, `[` and `]` cycle task detail sections, `,` and `.` cycle changed files, `{` and `}` cycle patch hunks, `A/C/Q/M` add review notes, `o/O` cycle existing threads, `T` reply, `E` edit, `R` resolve or reopen, `a` cycle thread assignee, `w` mark a thread as won't-fix, `x` mark it as accepted-risk, `F` queue a fix task, `H` queue a handoff task, `y/n` resolve approvals, and `c` opens the inline task composer with live route preview diagnostics.
+- Review filters are available both in the CLI and the TUI: `kavi reviews --assignee operator --status open`, and inside the console use `u`, `v`, and `d` to cycle assignee, status, and disposition filters for the active diff context.
+- The claims inspector now shows active overlap hotspots and ownership-rule conflicts so routing pressure points are visible directly in the operator surface.
 - Review threads now carry explicit assignees and richer dispositions, including `accepted risk` and `won't fix`, instead of relying only on free-form note text.
 - Successful follow-up tasks now auto-resolve linked open review threads, landed follow-up work marks those resolved threads as landed, and replying to a resolved thread reopens it.
 

package/dist/adapters/shared.js

@@ -4,11 +4,13 @@ function formatDecisionLine(summary, detail) {
     return detail.trim() ? `- ${summary}: ${detail}` : `- ${summary}`;
 }
 export function buildDecisionReplay(session, task, agent) {
+    const winningRule = task.routeMetadata?.winningRule && typeof task.routeMetadata.winningRule === "object" && !Array.isArray(task.routeMetadata.winningRule) && typeof task.routeMetadata.winningRule.pattern === "string" ? String(task.routeMetadata.winningRule.pattern) : null;
     const taskDecisions = session.decisions.filter((decision)=>decision.taskId === task.id).slice(-6).map((decision)=>formatDecisionLine(`[${decision.kind}] ${decision.summary}`, decision.detail));
     const sharedDecisions = session.decisions.filter((decision)=>decision.taskId !== task.id && (decision.agent === agent || decision.agent === null)).slice(-4).map((decision)=>formatDecisionLine(`[${decision.kind}] ${decision.summary}`, decision.detail));
     const relevantClaims = session.pathClaims.filter((claim)=>claim.status === "active" && (claim.taskId === task.id || claim.agent !== agent)).slice(-6).map((claim)=>`- ${claim.agent} ${claim.source} claim on ${claim.paths.join(", ")}${claim.note ? `: ${claim.note}` : ""}`);
     const replay = [
         `- Current route reason: ${task.routeReason ?? "not recorded"}`,
+        `- Winning ownership rule: ${winningRule ?? "none"}`,
         `- Current claimed paths: ${task.claimedPaths.join(", ") || "none"}`,
         ...taskDecisions,
         ...sharedDecisions,

package/dist/daemon.js

@@ -6,7 +6,7 @@ import { buildPeerMessages as buildClaudePeerMessages, runClaudeTask } from "./a
 import { buildPeerMessages as buildCodexPeerMessages, runCodexTask } from "./adapters/codex.js";
 import { buildDecisionReplay } from "./adapters/shared.js";
 import { listApprovalRequests, resolveApprovalRequest } from "./approvals.js";
-import { addDecisionRecord, upsertPathClaim } from "./decision-ledger.js";
+import { addDecisionRecord, releaseSupersededClaims, upsertPathClaim } from "./decision-ledger.js";
 import { getWorktreeDiffReview, listWorktreeChangedPaths } from "./git.js";
 import { nowIso } from "./paths.js";
 import { addReviewReply, addReviewNote, autoResolveReviewNotesForCompletedTask, linkReviewFollowUpTask, reviewNotesForTask, setReviewNoteStatus, updateReviewNote } from "./reviews.js";
@@ -284,6 +284,9 @@ export class KaviDaemon {
             const taskId = `task-${commandId}`;
             const task = buildAdHocTask(owner, prompt, taskId, {
                 routeReason: typeof params.routeReason === "string" ? params.routeReason : null,
+                routeStrategy: params.routeStrategy === "manual" || params.routeStrategy === "keyword" || params.routeStrategy === "ai" || params.routeStrategy === "path-claim" || params.routeStrategy === "fallback" ? params.routeStrategy : null,
+                routeConfidence: typeof params.routeConfidence === "number" ? params.routeConfidence : null,
+                routeMetadata: params.routeMetadata && typeof params.routeMetadata === "object" && !Array.isArray(params.routeMetadata) ? params.routeMetadata : {},
                 claimedPaths: Array.isArray(params.claimedPaths) ? params.claimedPaths.map((item)=>String(item)) : []
             });
             this.session.tasks.push(task);
@@ -296,7 +299,8 @@ export class KaviDaemon {
                 metadata: {
                     strategy: typeof params.routeStrategy === "string" ? params.routeStrategy : "unknown",
                     confidence: typeof params.routeConfidence === "number" ? params.routeConfidence : null,
-                    claimedPaths: task.claimedPaths
+                    claimedPaths: task.claimedPaths,
+                    routeMetadata: params.routeMetadata && typeof params.routeMetadata === "object" && !Array.isArray(params.routeMetadata) ? params.routeMetadata : {}
                 }
             });
             upsertPathClaim(this.session, {
@@ -621,6 +625,13 @@ export class KaviDaemon {
             promptLines.push(`Focus the change in ${note.filePath} and update the managed worktree accordingly.`);
             const task = buildAdHocTask(owner, promptLines.join(" "), taskId, {
                 routeReason: mode === "handoff" ? `Operator handed off review note ${note.id} to ${owner}.` : `Operator created a follow-up task from review note ${note.id}.`,
+                routeStrategy: "manual",
+                routeConfidence: 1,
+                routeMetadata: {
+                    source: "review-follow-up",
+                    mode,
+                    reviewNoteId: note.id
+                },
                 claimedPaths: [
                     note.filePath
                 ]
@@ -786,6 +797,9 @@ export class KaviDaemon {
                 const taskId = `task-${command.id}`;
                 const task = buildAdHocTask(owner, command.payload.prompt, taskId, {
                     routeReason: typeof command.payload.routeReason === "string" ? command.payload.routeReason : null,
+                    routeStrategy: command.payload.routeStrategy === "manual" || command.payload.routeStrategy === "keyword" || command.payload.routeStrategy === "ai" || command.payload.routeStrategy === "path-claim" || command.payload.routeStrategy === "fallback" ? command.payload.routeStrategy : null,
+                    routeConfidence: typeof command.payload.routeConfidence === "number" ? command.payload.routeConfidence : null,
+                    routeMetadata: command.payload.routeMetadata && typeof command.payload.routeMetadata === "object" && !Array.isArray(command.payload.routeMetadata) ? command.payload.routeMetadata : {},
                     claimedPaths: Array.isArray(command.payload.claimedPaths) ? command.payload.claimedPaths.map((item)=>String(item)) : []
                 });
                 this.session.tasks.push(task);
@@ -798,7 +812,8 @@ export class KaviDaemon {
                     metadata: {
                         strategy: typeof command.payload.routeStrategy === "string" ? command.payload.routeStrategy : "unknown",
                         confidence: typeof command.payload.routeConfidence === "number" ? command.payload.routeConfidence : null,
-                        claimedPaths: task.claimedPaths
+                        claimedPaths: task.claimedPaths,
+                        routeMetadata: command.payload.routeMetadata && typeof command.payload.routeMetadata === "object" && !Array.isArray(command.payload.routeMetadata) ? command.payload.routeMetadata : {}
                     }
                 });
                 upsertPathClaim(this.session, {
@@ -849,18 +864,7 @@ export class KaviDaemon {
             task.summary = envelope.summary;
             task.updatedAt = new Date().toISOString();
             if (task.owner === "codex" || task.owner === "claude") {
-                const worktree = this.session.worktrees.find((item)=>item.agent === task.owner);
-                if (worktree) {
-                    const changedPaths = await listWorktreeChangedPaths(worktree.path, this.session.baseCommit);
-                    task.claimedPaths = changedPaths;
-                    upsertPathClaim(this.session, {
-                        taskId: task.id,
-                        agent: task.owner,
-                        source: "diff",
-                        paths: changedPaths,
-                        note: task.summary
-                    });
-                }
+                await this.refreshTaskClaims(task);
             }
             addDecisionRecord(this.session, {
                 kind: "task",
@@ -901,6 +905,9 @@ export class KaviDaemon {
                 status: task.status,
                 summary: task.summary,
                 routeReason: task.routeReason,
+                routeStrategy: task.routeStrategy,
+                routeConfidence: task.routeConfidence,
+                routeMetadata: task.routeMetadata,
                 claimedPaths: task.claimedPaths,
                 decisionReplay,
                 rawOutput,
@@ -932,18 +939,7 @@ export class KaviDaemon {
             task.summary = error instanceof Error ? error.message : String(error);
             task.updatedAt = new Date().toISOString();
             if (task.owner === "codex" || task.owner === "claude") {
-                const worktree = this.session.worktrees.find((item)=>item.agent === task.owner);
-                if (worktree) {
-                    const changedPaths = await listWorktreeChangedPaths(worktree.path, this.session.baseCommit);
-                    task.claimedPaths = changedPaths;
-                    upsertPathClaim(this.session, {
-                        taskId: task.id,
-                        agent: task.owner,
-                        source: "diff",
-                        paths: changedPaths,
-                        note: task.summary
-                    });
-                }
+                await this.refreshTaskClaims(task);
             }
             addDecisionRecord(this.session, {
                 kind: "task",
@@ -968,6 +964,9 @@ export class KaviDaemon {
                 status: task.status,
                 summary: task.summary,
                 routeReason: task.routeReason,
+                routeStrategy: task.routeStrategy,
+                routeConfidence: task.routeConfidence,
+                routeMetadata: task.routeMetadata,
                 claimedPaths: task.claimedPaths,
                 decisionReplay,
                 rawOutput: null,
@@ -994,6 +993,77 @@ export class KaviDaemon {
             summary
         };
     }
+    async refreshTaskClaims(task) {
+        if (task.owner !== "codex" && task.owner !== "claude") {
+            return;
+        }
+        const worktree = this.session.worktrees.find((item)=>item.agent === task.owner);
+        if (!worktree) {
+            return;
+        }
+        const changedPaths = await listWorktreeChangedPaths(worktree.path, this.session.baseCommit);
+        const previousClaimedPaths = [
+            ...task.claimedPaths
+        ];
+        const hadClaimedSurface = previousClaimedPaths.length > 0 || this.session.pathClaims.some((claim)=>claim.taskId === task.id && claim.status === "active");
+        task.claimedPaths = changedPaths;
+        const claim = upsertPathClaim(this.session, {
+            taskId: task.id,
+            agent: task.owner,
+            source: "diff",
+            paths: changedPaths,
+            note: task.summary
+        });
+        if (claim && changedPaths.length > 0) {
+            const releasedClaims = releaseSupersededClaims(this.session, {
+                agent: task.owner,
+                taskId: task.id,
+                paths: changedPaths,
+                note: `Superseded by newer ${task.owner} diff claim from task ${task.id}.`
+            });
+            for (const releasedClaim of releasedClaims){
+                addDecisionRecord(this.session, {
+                    kind: "route",
+                    agent: task.owner,
+                    taskId: releasedClaim.taskId,
+                    summary: `Released superseded claim ${releasedClaim.id}`,
+                    detail: releasedClaim.paths.join(", ") || "No claimed paths.",
+                    metadata: {
+                        claimId: releasedClaim.id,
+                        supersededByTaskId: task.id,
+                        supersededByPaths: changedPaths
+                    }
+                });
+                await recordEvent(this.paths, this.session.id, "claim.superseded", {
+                    claimId: releasedClaim.id,
+                    taskId: releasedClaim.taskId,
+                    agent: releasedClaim.agent,
+                    paths: releasedClaim.paths,
+                    supersededByTaskId: task.id,
+                    supersededByPaths: changedPaths
+                });
+            }
+            return;
+        }
+        if (changedPaths.length === 0 && hadClaimedSurface) {
+            addDecisionRecord(this.session, {
+                kind: "route",
+                agent: task.owner,
+                taskId: task.id,
+                summary: `Released empty claim surface for ${task.id}`,
+                detail: "Task finished without a remaining worktree diff for its claimed paths.",
+                metadata: {
+                    releaseReason: "empty-diff-claim"
+                }
+            });
+            await recordEvent(this.paths, this.session.id, "claim.released", {
+                taskId: task.id,
+                agent: task.owner,
+                paths: previousClaimedPaths,
+                reason: "empty-diff-claim"
+            });
+        }
+    }
 }
 
 

package/dist/decision-ledger.js

@@ -1,11 +1,37 @@
+import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { nowIso } from "./paths.js";
 const MAX_DECISIONS = 80;
 function normalizePaths(paths) {
     return [
-        ...new Set(paths.map((item)=>item.trim()).filter(Boolean))
+        ...new Set(paths.map(normalizePath).filter(Boolean))
     ].sort();
 }
+function normalizePath(value) {
+    const trimmed = value.trim().replaceAll("\\", "/");
+    const withoutPrefix = trimmed.startsWith("./") ? trimmed.slice(2) : trimmed;
+    const normalized = path.posix.normalize(withoutPrefix);
+    return normalized === "." ? "" : normalized.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function pathOverlaps(left, right) {
+    const leftPath = normalizePath(left);
+    const rightPath = normalizePath(right);
+    if (!leftPath || !rightPath) {
+        return false;
+    }
+    return leftPath === rightPath || leftPath.startsWith(`${rightPath}/`) || rightPath.startsWith(`${leftPath}/`);
+}
+function overlapPath(left, right) {
+    const leftPath = normalizePath(left);
+    const rightPath = normalizePath(right);
+    if (!pathOverlaps(leftPath, rightPath)) {
+        return null;
+    }
+    if (leftPath === rightPath) {
+        return leftPath;
+    }
+    return leftPath.startsWith(`${rightPath}/`) ? leftPath : rightPath;
+}
 export function addDecisionRecord(session, input) {
     const record = {
         id: randomUUID(),
@@ -63,12 +89,132 @@ export function upsertPathClaim(session, input) {
 export function activePathClaims(session) {
     return session.pathClaims.filter((claim)=>claim.status === "active" && claim.paths.length > 0);
 }
+export function releasePathClaims(session, input = {}) {
+    const taskIds = input.taskIds ? new Set(input.taskIds) : null;
+    const released = [];
+    for (const claim of session.pathClaims){
+        if (claim.status !== "active") {
+            continue;
+        }
+        if (taskIds && !taskIds.has(claim.taskId)) {
+            continue;
+        }
+        claim.status = "released";
+        claim.updatedAt = nowIso();
+        if (input.note !== undefined) {
+            claim.note = input.note;
+        }
+        released.push(claim);
+    }
+    return released;
+}
+export function releaseSupersededClaims(session, input) {
+    const normalizedPaths = normalizePaths(input.paths);
+    if (normalizedPaths.length === 0) {
+        return [];
+    }
+    const released = [];
+    for (const claim of session.pathClaims){
+        if (claim.status !== "active" || claim.agent !== input.agent || claim.taskId === input.taskId) {
+            continue;
+        }
+        if (!claim.paths.some((item)=>normalizedPaths.some((candidate)=>pathOverlaps(item, candidate)))) {
+            continue;
+        }
+        claim.status = "released";
+        claim.updatedAt = nowIso();
+        if (input.note !== undefined) {
+            claim.note = input.note;
+        }
+        released.push(claim);
+    }
+    return released;
+}
 export function findClaimConflicts(session, owner, claimedPaths) {
     const normalizedPaths = normalizePaths(claimedPaths);
     if (normalizedPaths.length === 0) {
         return [];
     }
-    return activePathClaims(session).filter((claim)=>claim.agent !== owner && claim.paths.some((item)=>normalizedPaths.includes(item)));
+    return activePathClaims(session).filter((claim)=>claim.agent !== owner && claim.paths.some((item)=>normalizedPaths.some((candidate)=>pathOverlaps(item, candidate))));
+}
+export function buildClaimHotspots(session) {
+    const hotspots = new Map();
+    const claims = activePathClaims(session);
+    for(let index = 0; index < claims.length; index += 1){
+        const left = claims[index];
+        if (!left) {
+            continue;
+        }
+        for(let inner = index + 1; inner < claims.length; inner += 1){
+            const right = claims[inner];
+            if (!right || left.taskId === right.taskId) {
+                continue;
+            }
+            const overlappingPaths = left.paths.flatMap((leftPath)=>right.paths.map((rightPath)=>overlapPath(leftPath, rightPath)).filter((value)=>Boolean(value)));
+            if (overlappingPaths.length === 0) {
+                continue;
+            }
+            for (const hotspotPath of overlappingPaths){
+                const existing = hotspots.get(hotspotPath);
+                if (existing) {
+                    existing.overlapCount += 1;
+                    existing.agents = [
+                        ...new Set([
+                            ...existing.agents,
+                            left.agent,
+                            right.agent
+                        ])
+                    ];
+                    existing.taskIds = [
+                        ...new Set([
+                            ...existing.taskIds,
+                            left.taskId,
+                            right.taskId
+                        ])
+                    ];
+                    existing.claimIds = [
+                        ...new Set([
+                            ...existing.claimIds,
+                            left.id,
+                            right.id
+                        ])
+                    ];
+                    continue;
+                }
+                hotspots.set(hotspotPath, {
+                    path: hotspotPath,
+                    agents: [
+                        ...new Set([
+                            left.agent,
+                            right.agent
+                        ])
+                    ],
+                    taskIds: [
+                        ...new Set([
+                            left.taskId,
+                            right.taskId
+                        ])
+                    ],
+                    claimIds: [
+                        ...new Set([
+                            left.id,
+                            right.id
+                        ])
+                    ],
+                    overlapCount: 1
+                });
+            }
+        }
+    }
+    return [
+        ...hotspots.values()
+    ].sort((left, right)=>{
+        const overlapDelta = right.overlapCount - left.overlapCount;
+        if (overlapDelta !== 0) {
+            return overlapDelta;
+        }
+        return left.path.localeCompare(right.path);
+    });
 }
 
 

package/dist/doctor.js

@@ -1,4 +1,7 @@
+import path from "node:path";
+import { loadConfig } from "./config.js";
 import { fileExists } from "./fs.js";
+import { findOwnershipRuleConflicts } from "./ownership.js";
 import { runCommand } from "./process.js";
 import { hasSupportedNode, minimumNodeMajor, resolveSessionRuntime } from "./runtime.js";
 export function parseClaudeAuthStatus(output) {
@@ -19,12 +22,85 @@ export function parseClaudeAuthStatus(output) {
         };
     }
 }
+function normalizeRoutingPathRule(value) {
+    const trimmed = value.trim().replaceAll("\\", "/");
+    const withoutPrefix = trimmed.startsWith("./") ? trimmed.slice(2) : trimmed;
+    const normalized = path.posix.normalize(withoutPrefix);
+    return normalized === "." ? "" : normalized.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+export function validateRoutingPathRules(config) {
+    const issues = [];
+    const codexPaths = config.routing.codexPaths.map(normalizeRoutingPathRule);
+    const claudePaths = config.routing.claudePaths.map(normalizeRoutingPathRule);
+    const rawRules = [
+        ...config.routing.codexPaths.map((rule)=>({
+                owner: "codex",
+                raw: rule,
+                normalized: normalizeRoutingPathRule(rule)
+            })),
+        ...config.routing.claudePaths.map((rule)=>({
+                owner: "claude",
+                raw: rule,
+                normalized: normalizeRoutingPathRule(rule)
+            }))
+    ];
+    const blankRules = [
+        ...codexPaths,
+        ...claudePaths
+    ].filter((rule)=>!rule);
+    if (blankRules.length > 0) {
+        issues.push("Ownership path rules must not be empty.");
+    }
+    const absoluteRules = rawRules.filter(({ raw })=>{
+        const trimmed = raw.trim();
+        return trimmed.startsWith("/") || /^[A-Za-z]:[\\/]/.test(trimmed);
+    }).map(({ owner, raw })=>`${owner}:${raw}`);
+    if (absoluteRules.length > 0) {
+        issues.push(`Ownership path rules must be repo-relative, not absolute: ${absoluteRules.join(", ")}`);
+    }
+    const parentTraversalRules = rawRules.filter(({ normalized })=>normalized === ".." || normalized.startsWith("../")).map(({ owner, raw })=>`${owner}:${raw}`);
+    if (parentTraversalRules.length > 0) {
+        issues.push(`Ownership path rules must stay inside the repo root: ${parentTraversalRules.join(", ")}`);
+    }
+    const duplicateRules = (rules, owner)=>{
+        const seen = new Set();
+        const duplicates = new Set();
+        for (const rule of rules){
+            if (!rule) {
+                continue;
+            }
+            if (seen.has(rule)) {
+                duplicates.add(rule);
+            }
+            seen.add(rule);
+        }
+        if (duplicates.size > 0) {
+            issues.push(`${owner} has duplicate ownership rules: ${[
+                ...duplicates
+            ].join(", ")}`);
+        }
+    };
+    duplicateRules(codexPaths, "codex");
+    duplicateRules(claudePaths, "claude");
+    const overlappingRules = codexPaths.filter((rule)=>rule && claudePaths.includes(rule));
+    if (overlappingRules.length > 0) {
+        issues.push(`codex_paths and claude_paths overlap on the same exact rules: ${[
+            ...new Set(overlappingRules)
+        ].join(", ")}`);
+    }
+    const ambiguousConflicts = findOwnershipRuleConflicts(config).filter((conflict)=>conflict.kind === "ambiguous-overlap").map((conflict)=>`${conflict.leftOwner}:${conflict.leftPattern} <> ${conflict.rightOwner}:${conflict.rightPattern}`);
+    if (ambiguousConflicts.length > 0) {
+        issues.push(`Ownership rules have ambiguous overlaps without a specificity winner: ${ambiguousConflicts.join(", ")}`);
+    }
+    return issues;
+}
 function normalizeVersion(output) {
     return output.trim().split(/\s+/).slice(-1)[0] ?? output.trim();
 }
 export async function runDoctor(repoRoot, paths) {
     const checks = [];
     const runtime = await resolveSessionRuntime(paths);
+    const config = await loadConfig(paths);
     const nodeVersion = await runCommand(runtime.nodeExecutable, [
         "--version"
     ], {
@@ -104,6 +180,12 @@ export async function runDoctor(repoRoot, paths) {
         ok: true,
         detail: homeConfigCheck ? "present" : "will be created on demand"
     });
+    const routingRuleIssues = validateRoutingPathRules(config);
+    checks.push({
+        name: "routing-path-rules",
+        ok: routingRuleIssues.length === 0,
+        detail: routingRuleIssues.length === 0 ? "valid" : routingRuleIssues.join("; ")
+    });
     return checks;
 }