@dot-agent/language-server 0.4.1 → 0.5.0-alpha.2

package/merge-graph.js

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2026 Danilo Borges (https://github.com/daniloborges)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Workspace-discovery for the merge graph. This is IDE/tooling concern (it
+// scans a directory nobody explicitly pointed us at), not compiler concern
+// (the compiler only resolves imports from a known entry point, in
+// consolidate()) — but it still belongs in the *server*, not the VS Code
+// extension: the extension is a thin stdio transport with no fs access of
+// its own (see apps/vscode-extension/extension.js), and the server already
+// reads sibling files directly off disk for `agent/behaviorGraph`. That's
+// the standard LSP shape — tsserver/rust-analyzer scan their own project
+// tree server-side too, bounded by `workspaceFolders` from `initialize`.
+
+import { readdir, readFile } from 'node:fs/promises';
+import { join, dirname, resolve, relative, normalize, isAbsolute } from 'node:path';
+import { parseBehaviorFile, initBehaviorParser } from '@dot-agent/compiler';
+
+let workspaceRoots = [];
+
+/** Called once from onInitialize with the client's workspaceFolders/rootUri, as absolute fs paths. */
+export function setWorkspaceRoots(roots) {
+    workspaceRoots = roots.map(r => normalize(resolve(r)));
+}
+
+// Safety bound for the upward walk when no workspace boundary is known
+// (e.g. a single file opened outside any workspace folder).
+const MAX_UPWARD_HOPS = 8;
+
+/**
+ * Finds the agent root for `startDir`: the nearest ancestor directory
+ * containing a `*.description` file, mirroring the convention pack.ts's
+ * discoverDescriptionFile() uses to define an agent bundle. The walk never
+ * goes above a known workspace folder. Returns null if no manifest is found
+ * within bounds.
+ */
+export async function findAgentRoot(startDir) {
+    let dir = normalize(resolve(startDir));
+    const boundary = workspaceRoots.find(root => !relative(root, dir).startsWith('..')) ?? null;
+
+    for (let hops = 0; hops < MAX_UPWARD_HOPS; hops++) {
+        let entries;
+        try {
+            entries = await readdir(dir);
+        } catch {
+            return null;
+        }
+        if (entries.some(f => f.endsWith('.description'))) return dir;
+        if (boundary && dir === boundary) return null;
+        const parent = dirname(dir);
+        if (parent === dir) return null; // filesystem root
+        dir = parent;
+    }
+    return null;
+}
+
+async function collectBehaviorFiles(root, subdir = '', depth = 0, maxDepth = 6, out = []) {
+    if (depth > maxDepth) return out;
+    let entries;
+    try {
+        entries = await readdir(join(root, subdir), { withFileTypes: true });
+    } catch {
+        return out;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+        const rel = subdir ? `${subdir}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            await collectBehaviorFiles(root, rel, depth + 1, maxDepth, out);
+        } else if (entry.name.endsWith('.behavior')) {
+            out.push(rel);
+        }
+    }
+    return out;
+}
+
+/**
+ * Walks merge edges backward from `currentFile` (path relative to
+ * `agentRoot`) to find the root of its merge component. Returns null if no
+ * `.behavior` file under `agentRoot` merges `currentFile` (directly or
+ * transitively).
+ */
+export async function findMergeRoot(agentRoot, currentFile) {
+    // parseBehaviorFile() below calls straight into the WASM behavior-parser;
+    // unlike lintBehavior()/consolidate(), this function can run before
+    // anything else has triggered that init, so it must guard it itself.
+    await initBehaviorParser();
+    const normRoot = normalize(resolve(agentRoot));
+    const behaviorFiles = await collectBehaviorFiles(normRoot);
+
+    const parentOf = new Map();
+    for (const relEntry of behaviorFiles) {
+        const entryAbs = join(normRoot, relEntry);
+        let fileText;
+        try {
+            fileText = await readFile(entryAbs, 'utf-8');
+        } catch {
+            continue;
+        }
+        const merges = parseBehaviorFile(fileText).ok?.merges ?? [];
+        for (const mergePath of merges) {
+            if (isAbsolute(mergePath)) continue;
+            const mergeRel = relative(normRoot, resolve(dirname(entryAbs), mergePath));
+            if (mergeRel.startsWith('..')) continue; // merge escapes the agent root — not this lookup's concern
+            if (!parentOf.has(mergeRel)) parentOf.set(mergeRel, relEntry);
+        }
+    }
+
+    let node = currentFile;
+    const seen = new Set([node]);
+    while (parentOf.has(node)) {
+        node = parentOf.get(node);
+        if (seen.has(node)) return null; // circular merge — let consolidate() report E013
+        seen.add(node);
+    }
+    return node === currentFile ? null : node;
+}

package/package.json

@@ -1,37 +1,61 @@
 {
   "name": "@dot-agent/language-server",
-  "version": "0.4.1",
+  "version": "0.5.0-alpha.2",
   "description": "LSP server for .agent DSL files",
   "license": "Apache-2.0",
-  "author": "Danilo Borges <contato@daniloborg.es>",
+  "author": {
+    "name": "Danilo Borges",
+    "email": "contato@daniloborg.es",
+    "url": "https://daniloborg.es"
+  },
+  "contributors": [
+    {
+      "name": "Danilo Borges",
+      "email": "contato@daniloborg.es",
+      "url": "https://daniloborg.es"
+    }
+  ],
+  "homepage": "https://dot-agent.ai",
   "repository": {
     "type": "git",
-    "url": "https://github.com/dot-agent-spec/language-server.git"
+    "url": "https://github.com/dot-agent-spec/platform",
+    "directory": "packages/language-server"
   },
-  "homepage": "https://github.com/dot-agent-spec/language-server#readme",
   "bugs": {
-    "url": "https://github.com/dot-agent-spec/language-server/issues"
+    "url": "https://github.com/dot-agent-spec/platform/issues",
+    "email": "contato@daniloborg.es"
   },
   "keywords": [
     "lsp",
     "language-server",
     "agent",
+    "agents",
+    "llm",
     "dsl",
-    "flow"
+    "dot-agent"
   ],
+  "type": "module",
   "main": "server.js",
   "engines": {
     "node": ">=18"
   },
   "scripts": {
-    "start": "node server.js --stdio"
+    "start": "node server.js --stdio",
+    "build": "echo 'language-server ships JS source directly, no build step needed'",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
-    "@dot-agent/tree-sitter": "^0.3.6",
+    "@dot-agent/parser-dsl": "0.5.0-alpha.1",
+    "@dot-agent/compiler": "0.5.0-alpha.2",
+    "@dot-agent/tree-sitter": "0.5.0-alpha.1",
     "vscode-languageserver": "^10.0.0",
     "vscode-languageserver-textdocument": "^1.0.12",
     "web-tree-sitter": "^0.26.9"
   },
+  "devDependencies": {
+    "vitest": "^1.6.0"
+  },
   "publishConfig": {
     "access": "public"
   }

package/parser.js

@@ -14,19 +14,20 @@
  * limitations under the License.
  */
 
-'use strict';
+import { resolve } from 'path';
+import { createRequire } from 'module';
+import { Parser, Language } from 'web-tree-sitter';
 
-const path = require('path');
-const { Parser, Language } = require('web-tree-sitter');
+const require = createRequire(import.meta.url);
 const grammar = require('@dot-agent/tree-sitter');
 
 // path.resolve ensures absolute paths survive vsix packaging and cwd changes
-const DESCRIPTION_WASM = path.resolve(grammar.agentWasmPath);
-const BEHAVIOR_WASM  = path.resolve(grammar.behaviorWasmPath);
+const DESCRIPTION_WASM = resolve(grammar.descriptionWasmPath);
+const BEHAVIOR_WASM  = resolve(grammar.behaviorWasmPath);
 
 let descriptionParser, behaviorParser;
 
-async function initParsers() {
+export async function initParsers() {
     await Parser.init();
     const DescriptionLang = await Language.load(DESCRIPTION_WASM);
     const Behavior  = await Language.load(BEHAVIOR_WASM);
@@ -39,21 +40,27 @@ async function initParsers() {
 // Cache: uri → { version, tree }
 const cache = new Map();
 
-function parse(uri, langId, text, version) {
+export function parse(uri, langId, text, version) {
     const prev = cache.get(uri);
     if (prev?.version === version) return prev.tree;
     const parser = langId === 'behavior' ? behaviorParser : descriptionParser;
     if (!parser) return null;
-    const tree = parser.parse(text, prev?.tree);   // incremental reuse when possible
+    // Full reparse: reusing prev.tree here would be tree-sitter's incremental
+    // mode, which requires calling tree.edit() with the exact change range
+    // beforehand. We don't have that range (TextDocuments only hands us the
+    // post-change text), so passing the stale tree as a hint corrupts node
+    // byte ranges — .text on a shifted node silently returns garbled or
+    // empty strings (surfaces as "name must not be falsy" in documentSymbol).
+    const tree = parser.parse(text);
     cache.set(uri, { version, tree });
     return tree;
 }
 
-function evict(uri) {
+export function evict(uri) {
     cache.delete(uri);
 }
 
-function parseText(langId, text) {
+export function parseText(langId, text) {
     const parser = langId === 'behavior' ? behaviorParser : descriptionParser;
     if (!parser) return null;
     return parser.parse(text);
@@ -61,18 +68,18 @@ function parseText(langId, text) {
 
 // ── AST helpers ──────────────────────────────────────────────────────────────
 
-function nodesOfType(tree, type) {
+export function nodesOfType(tree, type) {
     if (!tree) return [];
     return tree.rootNode.descendantsOfType(type);
 }
 
-function nodeAtOffset(tree, offset) {
+export function nodeAtOffset(tree, offset) {
     if (!tree) return null;
     return tree.rootNode.descendantForIndex(offset);
 }
 
 // Convert a tree-sitter {row, column} position to an LSP Range
-function nodeToRange(node) {
+export function nodeToRange(node) {
     return {
         start: { line: node.startPosition.row, character: node.startPosition.column },
         end:   { line: node.endPosition.row,   character: node.endPosition.column },
@@ -80,7 +87,7 @@ function nodeToRange(node) {
 }
 
 // Convert LSP position (line, character) to a byte offset in text
-function positionToOffset(text, line, character) {
+export function positionToOffset(text, line, character) {
     let offset = 0;
     for (let i = 0; i < line; i++) {
         const nl = text.indexOf('\n', offset);
@@ -90,7 +97,7 @@ function positionToOffset(text, line, character) {
 }
 
 // Extract the word (identifier chars including dots) around position
-function wordAtPosition(text, line, character) {
+export function wordAtPosition(text, line, character) {
     const lines = text.split('\n');
     const lineText = lines[line] || '';
     let start = character, end = character;
@@ -100,7 +107,7 @@ function wordAtPosition(text, line, character) {
 }
 
 // Walk up the tree from offset, skipping ERROR/MISSING nodes
-function getContextNode(tree, offset) {
+export function getContextNode(tree, offset) {
     let node = nodeAtOffset(tree, offset);
     while (node && (node.isError || node.isMissing)) {
         node = node.parent;
@@ -118,16 +125,3 @@ function getContextNode(tree, offset) {
     }
     return node ?? tree?.rootNode;
 }
-
-module.exports = {
-    initParsers,
-    parse,
-    parseText,
-    evict,
-    nodesOfType,
-    nodeAtOffset,
-    nodeToRange,
-    positionToOffset,
-    wordAtPosition,
-    getContextNode,
-};

package/server.js

@@ -14,39 +14,48 @@
  * limitations under the License.
  */
 
-'use strict';
-
-const {
+import {
     createConnection,
     TextDocuments,
     ProposedFeatures,
     TextDocumentSyncKind,
-    SymbolKind,
-} = require('vscode-languageserver/node');
-const { TextDocument } = require('vscode-languageserver-textdocument');
-
-const { initParsers, parse, evict, nodesOfType } = require('./parser');
-
-const { provideHover }          = require('./features/hover');
-const { provideCompletions }    = require('./features/completions');
-const { diagnose }              = require('./features/diagnostics');
-const { provideDocumentSymbols }= require('./features/symbols');
-const { provideDefinition }     = require('./features/definition');
-const { provideReferences }     = require('./features/references');
-const { provideRenameEdits }    = require('./features/rename');
-const { format }                = require('./features/formatting');
-const { provideDocumentLinks }  = require('./features/links');
-const { extractBehaviorGraph }  = require('./features/graph');
+} from 'vscode-languageserver/node';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { init as bpInit, get_graph } from '@dot-agent/parser-dsl';
+import { consolidate } from '@dot-agent/compiler';
+import { fileURLToPath } from 'url';
+import { dirname, relative } from 'node:path';
+
+import { initParsers, parse, evict, nodesOfType } from './parser.js';
+import { setWorkspaceRoots, findAgentRoot } from './merge-graph.js';
+
+import { provideHover }           from './features/hover.js';
+import { provideCompletions }     from './features/completions.js';
+import { diagnose }               from './features/diagnostics.js';
+import { provideDocumentSymbols } from './features/symbols.js';
+import { provideDefinition }      from './features/definition.js';
+import { provideReferences }      from './features/references.js';
+import { provideRenameEdits }     from './features/rename.js';
+import { format }                 from './features/formatting.js';
+import { provideDocumentLinks }   from './features/links.js';
 
 const connection = createConnection(ProposedFeatures.all);
 const documents  = new TextDocuments(TextDocument);
 
 // ── Initialization ───────────────────────────────────────────────────────────
 
-// web-tree-sitter is strictly async — await before advertising capabilities
-// so no feature handler fires before parsers are ready.
-connection.onInitialize(async () => {
+// web-tree-sitter and behavior-parser are strictly async — await before
+// advertising capabilities so no feature handler fires before parsers are ready.
+connection.onInitialize(async (params) => {
     await initParsers();
+    await bpInit();
+    const roots = (params.workspaceFolders ?? [])
+        .map(f => { try { return fileURLToPath(f.uri); } catch { return null; } })
+        .filter(Boolean);
+    if (roots.length === 0 && params.rootUri) {
+        try { roots.push(fileURLToPath(params.rootUri)); } catch { /* non-file root, ignore */ }
+    }
+    setWorkspaceRoots(roots);
     return {
         capabilities: {
             textDocumentSync: TextDocumentSyncKind.Incremental,
@@ -70,11 +79,10 @@ function getTree(doc) {
 
 // ── Diagnostics (push on change) ─────────────────────────────────────────────
 
-function validate(doc) {
+async function validate(doc) {
     const langId = doc.languageId;
     if (langId !== 'description' && langId !== 'behavior') return;
-    const tree = getTree(doc);
-    const diagnostics = diagnose(langId, tree, doc.getText(), doc.uri);
+    const diagnostics = await diagnose(doc.uri, langId, doc.getText());
     connection.sendDiagnostics({ uri: doc.uri, diagnostics });
 }
 
@@ -166,11 +174,20 @@ connection.onDocumentFormatting(({ textDocument }) => {
 
 // ── Behavior Graph (custom request) ──────────────────────────────────────────
 
-connection.onRequest('agent/behaviorGraph', ({ uri }) => {
+connection.onRequest('agent/behaviorGraph', async ({ uri }) => {
     const doc = documents.get(uri);
     if (!doc || doc.languageId !== 'behavior') return null;
-    const tree = getTree(doc);
-    return tree ? extractBehaviorGraph(tree) : null;
+    const text = doc.getText();
+    if (/^\s*merge\s+/m.test(text)) {
+        try {
+            let filePath;
+            try { filePath = fileURLToPath(uri); } catch { filePath = uri; }
+            const agentRoot = (await findAgentRoot(dirname(filePath))) ?? dirname(filePath);
+            const { mergedText } = await consolidate(agentRoot, relative(agentRoot, filePath));
+            return get_graph(mergedText);
+        } catch { /* fallback to single-file graph */ }
+    }
+    return get_graph(text);
 });
 
 // ── Current State at Position (custom request) ────────────────────────────────

package/tests/diagnostics.test.js

@@ -0,0 +1,209 @@
+// Copyright (c) 2026 Danilo Borges (https://github.com/daniloborges)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+
+import { describe, it, expect, afterEach } from 'vitest'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { pathToFileURL } from 'node:url'
+import { diagnose } from '../features/diagnostics.js'
+import { setWorkspaceRoots } from '../merge-graph.js'
+
+// file:// URIs so fileURLToPath doesn't throw
+const BEHAVIOR_URI = 'file:///test.behavior'
+const DESC_URI     = 'file:///test.description'
+
+// ── behavior ──────────────────────────────────────────────────────────────────
+
+// Valid oriented state: goal + interact + on intent (block) + on offtopic (block)
+const VALID_BEHAVIOR = `\
+state init
+  transition to responsive
+
+state responsive
+  goal "How can I help?"
+  interact
+  on intent "go"
+    transition to init
+  on offtopic
+    transition to responsive
+`
+
+describe('diagnose — behavior — valid', () => {
+    it('returns no errors for well-formed behavior', async () => {
+        const diags = await diagnose(BEHAVIOR_URI, 'behavior', VALID_BEHAVIOR)
+        const errors = diags.filter(d => d.severity === 1) // DiagnosticSeverity.Error
+        expect(errors).toHaveLength(0)
+    })
+})
+
+describe('diagnose — behavior — E005 dangling transition', () => {
+    it('reports error for transition to undefined state', async () => {
+        const text = 'state init\n  transition to ghost\n'
+        const diags = await diagnose(BEHAVIOR_URI, 'behavior', text)
+        const e005 = diags.filter(d => d.message.includes('E005'))
+        expect(e005.length).toBeGreaterThan(0)
+        expect(e005[0].severity).toBe(1) // Error
+    })
+})
+
+describe('diagnose — behavior — W002 long text', () => {
+    it('warns when goal text exceeds 280 characters', async () => {
+        const long = 'a'.repeat(281)
+        const text = `state init\n  goal "${long}"\n  transition to init\n`
+        const diags = await diagnose(BEHAVIOR_URI, 'behavior', text)
+        const w002 = diags.filter(d => d.message.includes('W002'))
+        expect(w002.length).toBeGreaterThan(0)
+        expect(w002[0].severity).toBe(2) // Warning
+    })
+})
+
+// ── description ───────────────────────────────────────────────────────────────
+
+const VALID_DESCRIPTION = `\
+agent Doctor
+  domain health.example.com
+  license MIT
+
+description
+  Clinical diagnostic agent.
+
+capabilities
+  DiagnoseAction "Emit a structured diagnosis"
+
+input Patient
+output Prescription
+`
+
+describe('diagnose — description — valid', () => {
+    it('returns no errors for well-formed description', async () => {
+        const diags = await diagnose(DESC_URI, 'description', VALID_DESCRIPTION)
+        const errors = diags.filter(d => d.severity === 1)
+        expect(errors).toHaveLength(0)
+    })
+})
+
+describe('diagnose — description — W003 default domain', () => {
+    it('warns when domain is still "example.com"', async () => {
+        const text = VALID_DESCRIPTION.replace('health.example.com', 'example.com')
+        const diags = await diagnose(DESC_URI, 'description', text)
+        const w003 = diags.filter(d => d.message.includes('W003'))
+        expect(w003.length).toBeGreaterThan(0)
+        expect(w003[0].severity).toBe(2) // Warning
+    })
+})
+
+describe('diagnose — behavior — E016 missing init state', () => {
+    it('reports error when no init state exists', async () => {
+        const text = 'state lobby\n  goal "Welcome"\n  interact\n'
+        const diags = await diagnose(BEHAVIOR_URI, 'behavior', text)
+        const e016 = diags.filter(d => d.message.includes('E016'))
+        expect(e016.length).toBeGreaterThan(0)
+        expect(e016[0].severity).toBe(1) // Error
+    })
+})
+
+// ── unknown langId ────────────────────────────────────────────────────────────
+
+describe('diagnose — unknown langId', () => {
+    it('returns empty array', async () => {
+        const diags = await diagnose(BEHAVIOR_URI, 'unknown', 'anything')
+        expect(diags).toHaveLength(0)
+    })
+})
+
+// ── merge: fragment files & line-shift regressions ─────────────────────────────
+//
+// Reproduces the real-world bug: an agent with `main.behavior` (has `merge`)
+// and a fragment file it merges in that has no `merge` of its own. These
+// tests need real files on disk because findAgentRoot/findMergeRoot/
+// consolidate all read the agent directory, unlike the in-memory cases above.
+
+let tmpDir
+
+async function makeMergedAgent(files) {
+    tmpDir = await mkdtemp(join(tmpdir(), 'language-server-diagnostics-test-'))
+    setWorkspaceRoots([tmpDir])
+    await writeFile(
+        join(tmpDir, 'agent.description'),
+        'agent Tour\n  domain example.com\n  license MIT\n\ndescription\n  Tour agent.\n\nbehavior main.behavior\n'
+    )
+    for (const [name, content] of Object.entries(files)) {
+        await writeFile(join(tmpDir, name), content)
+    }
+    return tmpDir
+}
+
+function uriFor(dir, name) {
+    return pathToFileURL(join(dir, name)).toString()
+}
+
+afterEach(async () => {
+    setWorkspaceRoots([])
+    if (tmpDir) {
+        await rm(tmpDir, { recursive: true, force: true })
+        tmpDir = ''
+    }
+})
+
+const MAIN_BEHAVIOR = `\
+merge "fragment.behavior"
+
+state init
+  transition to responsive
+
+state responsive
+  goal "Welcome to the tour."
+  interact
+  on intent "start" transition to frag_state_a
+  on intent "start" transition to responsive
+  on offtopic transition to responsive
+`
+
+const FRAGMENT_BEHAVIOR = `\
+state frag_state_a
+  goal "Fragment step."
+  interact
+  on intent "next" transition to responsive
+  on offtopic transition to responsive
+`
+
+describe('diagnose — merge — fragment file merged by another file', () => {
+    it('does not report E005 for a transition target defined in the parent file', async () => {
+        const dir = await makeMergedAgent({ 'main.behavior': MAIN_BEHAVIOR, 'fragment.behavior': FRAGMENT_BEHAVIOR })
+        const diags = await diagnose(uriFor(dir, 'fragment.behavior'), 'behavior', FRAGMENT_BEHAVIOR)
+        const e005 = diags.filter(d => d.message.includes('E005'))
+        expect(e005).toHaveLength(0)
+    })
+
+    it('does not report E016 (missing init) on a fragment that has no init of its own', async () => {
+        const dir = await makeMergedAgent({ 'main.behavior': MAIN_BEHAVIOR, 'fragment.behavior': FRAGMENT_BEHAVIOR })
+        const diags = await diagnose(uriFor(dir, 'fragment.behavior'), 'behavior', FRAGMENT_BEHAVIOR)
+        const e016 = diags.filter(d => d.message.includes('E016'))
+        expect(e016).toHaveLength(0)
+    })
+
+    it('still reports whole-tree E016 when neither the root nor the fragment declares init', async () => {
+        const noInitMain = MAIN_BEHAVIOR.replace('state init\n  transition to responsive\n\n', '')
+        const dir = await makeMergedAgent({ 'main.behavior': noInitMain, 'fragment.behavior': FRAGMENT_BEHAVIOR })
+        const diags = await diagnose(uriFor(dir, 'main.behavior'), 'behavior', noInitMain)
+        const e016 = diags.filter(d => d.message.includes('E016'))
+        expect(e016.length).toBeGreaterThan(0)
+    })
+})
+
+describe('diagnose — merge — local diagnostics keep this file\'s own line numbers', () => {
+    it('reports W008 (duplicate intent) at its real line in main.behavior, not shifted by the merged fragment', async () => {
+        const dir = await makeMergedAgent({ 'main.behavior': MAIN_BEHAVIOR, 'fragment.behavior': FRAGMENT_BEHAVIOR })
+        const diags = await diagnose(uriFor(dir, 'main.behavior'), 'behavior', MAIN_BEHAVIOR)
+        const w008 = diags.filter(d => d.message.includes('W008'))
+        expect(w008).toHaveLength(1)
+        // line 10 (1-indexed) is the duplicate `on intent "start"` inside `state responsive`
+        expect(w008[0].range.start.line).toBe(9)
+    })
+})