@dotdotgod/hermes 0.6.0 → 0.6.2

package/mcp/cli.mjs

@@ -1,5 +1,759 @@
 #!/usr/bin/env node
 // Generated by scripts/build-adapter-runtime.mjs; optional embedding runtime is packaged separately.
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js"(exports, module) {
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var UNDEFINED = void 0;
+    var EMPTY = "";
+    var SPACE = " ";
+    var ESCAPE = "\\";
+    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+    var REGEX_TEST_TRAILING_SLASH = /\/$/;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = /* @__PURE__ */ Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define = (object, key, value) => {
+      Object.defineProperty(object, key, { value });
+      return value;
+    };
+    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var RETURN_FALSE = () => false;
+    var sanitizeRange = (range) => range.replace(
+      REGEX_REGEXP_RANGE,
+      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
+    );
+    var cleanRangeBackSlash = (slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    };
+    var REPLACERS = [
+      [
+        // Remove BOM
+        // TODO:
+        // Other similar zero-width characters?
+        /^\uFEFF/,
+        () => EMPTY
+      ],
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a ) -> (a)
+        // (a \ ) -> (a  )
+        /((?:\\\\)*?)(\\?\s+)$/,
+        (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+      ],
+      // Replace (\ ) with ' '
+      // (\ ) -> ' '
+      // (\\ ) -> '\\ '
+      // (\\\ ) -> '\\ '
+      [
+        /(\\+?)\s/g,
+        (_, m1) => {
+          const { length } = m1;
+          return m1.slice(0, length - length % 2) + SPACE;
+        }
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match) => `\\${match}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^"
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/"
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*\\\*\\\*\\\//,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        /^(?=[^^])/,
+        function startingReplacer() {
+          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        }
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_, p1, p2) => {
+          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        }
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE
+      ],
+      [
+        // > The range notation, e.g. [a-zA-Z],
+        // > can be used to match one of the characters in a range.
+        // `\` is escaped by step 3
+        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        /(?:[^*])$/,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+      ]
+    ];
+    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+    var MODE_IGNORE = "regex";
+    var MODE_CHECK_IGNORE = "checkRegex";
+    var UNDERSCORE = "_";
+    var TRAILING_WILD_CARD_REPLACERS = {
+      [MODE_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      },
+      [MODE_CHECK_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      }
+    };
+    var makeRegexPrefix = (pattern) => REPLACERS.reduce(
+      (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
+      pattern
+    );
+    var isString = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+    var IgnoreRule = class {
+      constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+        this.pattern = pattern;
+        this.mark = mark;
+        this.negative = negative;
+        define(this, "body", body);
+        define(this, "ignoreCase", ignoreCase);
+        define(this, "regexPrefix", prefix);
+      }
+      get regex() {
+        const key = UNDERSCORE + MODE_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_IGNORE, key);
+      }
+      get checkRegex() {
+        const key = UNDERSCORE + MODE_CHECK_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_CHECK_IGNORE, key);
+      }
+      _make(mode, key) {
+        const str = this.regexPrefix.replace(
+          REGEX_REPLACE_TRAILING_WILDCARD,
+          // It does not need to bind pattern
+          TRAILING_WILD_CARD_REPLACERS[mode]
+        );
+        const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+        return define(this, key, regex);
+      }
+    };
+    var createRule = ({
+      pattern,
+      mark
+    }, ignoreCase) => {
+      let negative = false;
+      let body = pattern;
+      if (body.indexOf("!") === 0) {
+        negative = true;
+        body = body.substr(1);
+      }
+      body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regexPrefix = makeRegexPrefix(body);
+      return new IgnoreRule(
+        pattern,
+        mark,
+        body,
+        ignoreCase,
+        negative,
+        regexPrefix
+      );
+    };
+    var RuleManager = class {
+      constructor(ignoreCase) {
+        this._ignoreCase = ignoreCase;
+        this._rules = [];
+      }
+      _add(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules._rules);
+          this._added = true;
+          return;
+        }
+        if (isString(pattern)) {
+          pattern = {
+            pattern
+          };
+        }
+        if (checkPattern(pattern.pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._add, this);
+        return this._added;
+      }
+      // Test one single path without recursively checking parent directories
+      //
+      // - checkUnignored `boolean` whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
+      // @returns {TestResult} true if a file is ignored
+      test(path, checkUnignored, mode) {
+        let ignored2 = false;
+        let unignored = false;
+        let matchedRule;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored2 !== unignored || negative && !ignored2 && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule[mode].test(path);
+          if (!matched) {
+            return;
+          }
+          ignored2 = !negative;
+          unignored = negative;
+          matchedRule = negative ? UNDEFINED : rule;
+        });
+        const ret = {
+          ignored: ignored2,
+          unignored
+        };
+        if (matchedRule) {
+          ret.rule = matchedRule;
+        }
+        return ret;
+      }
+    };
+    var throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path, originalPath, doThrow) => {
+      if (!isString(path)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define(this, KEY_IGNORE, true);
+        this._rules = new RuleManager(ignoreCase);
+        this._strictPathCheck = !allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      add(pattern) {
+        if (this._rules.add(pattern)) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored, slices) {
+        const path = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path,
+          originalPath,
+          this._strictPathCheck ? throwError : RETURN_FALSE
+        );
+        return this._t(path, cache, checkUnignored, slices);
+      }
+      checkIgnore(path) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path)) {
+          return this.test(path);
+        }
+        const slices = path.split(SLASH).filter(Boolean);
+        slices.pop();
+        if (slices.length) {
+          const parent = this._t(
+            slices.join(SLASH) + SLASH,
+            this._testCache,
+            true,
+            slices
+          );
+          if (parent.ignored) {
+            return parent;
+          }
+        }
+        return this._rules.test(path, false, MODE_CHECK_IGNORE);
+      }
+      _t(path, cache, checkUnignored, slices) {
+        if (path in cache) {
+          return cache[path];
+        }
+        if (!slices) {
+          slices = path.split(SLASH).filter(Boolean);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path] = parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
+      }
+      ignores(path) {
+        return this._test(path, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path) => !this.ignores(path);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path) {
+        return this._test(path, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore(options);
+    var isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+    var setupWindows = () => {
+      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+    };
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && process.platform === "win32"
+    ) {
+      setupWindows();
+    }
+    module.exports = factory;
+    factory.default = factory;
+    module.exports.isPathValid = isPathValid;
+    define(module.exports, /* @__PURE__ */ Symbol.for("setupWindows"), setupWindows);
+  }
+});
+
+// packages/cli/src/symbols/languages.mjs
+import { extname as extname4 } from "node:path";
+function languageForPath(path) {
+  return Object.entries(LANGUAGE_EXTENSIONS).find(([, extensions]) => extensions.includes(extname4(path)))?.[0] ?? null;
+}
+var LANGUAGE_EXTENSIONS, SOURCE_EXTENSIONS, EXTRACTOR_ID, DECLARATIONS, COMMENT_TYPES;
+var init_languages = __esm({
+  "packages/cli/src/symbols/languages.mjs"() {
+    LANGUAGE_EXTENSIONS = {
+      javascript: [".js", ".jsx", ".mjs", ".cjs"],
+      typescript: [".ts"],
+      tsx: [".tsx"],
+      python: [".py", ".pyw"],
+      go: [".go"],
+      rust: [".rs"],
+      java: [".java"],
+      ruby: [".rb"],
+      php: [".php"],
+      "c-sharp": [".cs"],
+      cpp: [".cpp", ".cc", ".cxx", ".hpp"],
+      bash: [".sh", ".bash"],
+      powershell: [".ps1"]
+    };
+    SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+      ...Object.values(LANGUAGE_EXTENSIONS).flat(),
+      ".c",
+      ".h",
+      ".kt",
+      ".kts",
+      ".swift",
+      ".scala",
+      ".clj",
+      ".cljs",
+      ".ex",
+      ".exs",
+      ".erl",
+      ".hrl",
+      ".lua",
+      ".pl",
+      ".pm",
+      ".r",
+      ".R",
+      ".sql",
+      ".m",
+      ".mm",
+      ".zsh",
+      ".fish"
+    ]);
+    EXTRACTOR_ID = "outline-v3:vscode-tree-sitter-wasm-0.3.1";
+    DECLARATIONS = {
+      function_declaration: "function",
+      generator_function_declaration: "function",
+      function_definition: "function",
+      function_item: "function",
+      function_signature_item: "function",
+      function_signature: "function",
+      method_definition: "method",
+      method_declaration: "method",
+      method_signature: "method",
+      method: "method",
+      singleton_method: "method",
+      constructor_declaration: "constructor",
+      destructor_declaration: "destructor",
+      class_declaration: "class",
+      class_definition: "class",
+      class: "class",
+      class_specifier: "class",
+      struct_specifier: "struct",
+      interface_declaration: "interface",
+      interface_definition: "interface",
+      trait_item: "trait",
+      struct_item: "struct",
+      enum_item: "enum",
+      enum_declaration: "enum",
+      record_declaration: "class",
+      namespace_definition: "namespace",
+      mod_item: "module",
+      module: "module",
+      function_statement: "function"
+    };
+    COMMENT_TYPES = /* @__PURE__ */ new Set(["comment", "line_comment", "block_comment"]);
+  }
+});
+
+// packages/cli/src/symbols/runtime.mjs
+import { createRequire } from "node:module";
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "node:fs";
+import { dirname as dirname5, join as join8 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash as createHash4 } from "node:crypto";
+function parserEntry() {
+  const bundled = fileURLToPath(new URL("./parsers/tree-sitter.cjs", import.meta.url));
+  return existsSync9(bundled) ? bundled : require2.resolve("@vscode/tree-sitter-wasm");
+}
+function parserIdentity() {
+  if (!identity) {
+    const entry = parserEntry();
+    const hash2 = createHash4("sha256").update(readFileSync9(entry));
+    for (const name of ["tree-sitter.wasm", ...Object.keys(LANGUAGE_EXTENSIONS).map((language) => `tree-sitter-${language}.wasm`)]) hash2.update(name).update(readFileSync9(join8(dirname5(entry), name)));
+    identity = hash2.digest("hex");
+  }
+  return identity;
+}
+function loadParserApi() {
+  return require2(parserEntry());
+}
+var require2, identity;
+var init_runtime = __esm({
+  "packages/cli/src/symbols/runtime.mjs"() {
+    init_languages();
+    require2 = createRequire(import.meta.url);
+  }
+});
+
+// packages/cli/src/symbols/parser.mjs
+var parser_exports = {};
+__export(parser_exports, {
+  extractSymbols: () => extractSymbols
+});
+import { dirname as dirname6, join as join10 } from "node:path";
+import { createHash as createHash5 } from "node:crypto";
+async function parserFor(language) {
+  if (!runtime) runtime = (async () => {
+    const entry = parserEntry();
+    const api2 = loadParserApi();
+    await api2.Parser.init();
+    return { api: api2, directory: dirname6(entry) };
+  })();
+  const { api, directory } = await runtime;
+  if (!languages.has(language)) languages.set(language, api.Language.load(join10(directory, `tree-sitter-${language}.wasm`)));
+  const loaded = await languages.get(language);
+  const parser = new api.Parser();
+  parser.setLanguage(loaded);
+  return parser;
+}
+function declaredName(node2) {
+  const name = field(node2, "name") ?? node2.namedChildren.find((child) => child.type === "function_name");
+  if (name) return name.text;
+  const declarator = field(node2, "declarator");
+  if (declarator) return declaredName(declarator) || (["identifier", "field_identifier"].includes(declarator.type) ? declarator.text : "");
+  return "";
+}
+function declarationHeader(node2, source, end) {
+  const cuts = [];
+  function visit(child) {
+    const body = field(child, "body");
+    if (body && body.startIndex < end && body.endIndex <= end) {
+      cuts.push([body.startIndex, body.endIndex]);
+      return;
+    }
+    for (const nested of child.namedChildren) if (nested.startIndex < end) visit(nested);
+  }
+  visit(node2);
+  let header = source.slice(node2.startIndex, end);
+  for (const [start, finish] of cuts.sort((a, b) => b[0] - a[0])) header = header.slice(0, start - node2.startIndex) + "\u2026" + header.slice(finish - node2.startIndex);
+  return header.trim();
+}
+function documentation(node2, body, language, source) {
+  if (language === "python") {
+    const first = body?.namedChildren[0];
+    const string = first?.type === "expression_statement" ? first.namedChildren[0] : null;
+    const literals = string?.type === "concatenated_string" ? string.namedChildren : string ? [string] : [];
+    const valid = literals.length && literals.every((literal) => literal.type === "string" && /^[rRuU]*['"]/.test(literal.text));
+    return valid ? { text: string.text, startLine: string.startPosition.row + 1 } : { text: "" };
+  }
+  let anchor = node2;
+  while (anchor.parent && (["export_statement", "decorated_definition"].includes(anchor.parent.type) || ["lexical_declaration", "variable_declaration"].includes(anchor.parent.type) && !anchor.previousNamedSibling || language === "powershell" && anchor.parent.type === "statement_list" && !anchor.previousNamedSibling)) anchor = anchor.parent;
+  const comments = [];
+  let previous = anchor.previousNamedSibling;
+  let start = anchor.startIndex;
+  while (previous && source.slice(previous.endIndex, start).trim() === "") {
+    if (COMMENT_TYPES.has(previous.type)) comments.unshift(previous);
+    else if (!(language === "rust" && previous.type === "attribute_item")) break;
+    start = previous.startIndex;
+    previous = previous.previousNamedSibling;
+  }
+  const markers = ["javascript", "typescript", "tsx", "java", "php"].includes(language) ? /^\/\*\*/ : language === "rust" ? /^(\/\/\/(?!\/)|\/\*\*)/ : ["cpp", "c-sharp"].includes(language) ? /^(\/\*\*|\/\/\/|\/\/!|\/\*!)/ : null;
+  const docs = markers ? comments.filter((comment) => markers.test(comment.text)) : comments;
+  return { text: docs.map((comment) => comment.text).join("\n"), startLine: docs[0] ? docs[0].startPosition.row + 1 : void 0 };
+}
+async function extractSymbols(path, source, language) {
+  const parser = await parserFor(language);
+  let tree;
+  try {
+    let walk = function(node2, owner = null) {
+      let kind = DECLARATIONS[node2.type];
+      let declaration = node2;
+      let body = field(node2, "body") ?? (language === "powershell" ? node2.namedChildren.find((child) => child.type === "script_block") : null);
+      if (["variable_declarator", "public_field_definition"].includes(node2.type)) {
+        const value = field(node2, "value");
+        if (value && ["arrow_function", "function_expression", "generator_function"].includes(value.type)) {
+          kind = "function";
+          body = field(value, "body");
+        }
+      }
+      if (node2.type === "type_spec" && ["struct_type", "interface_type"].includes(field(node2, "type")?.type)) {
+        kind = "class";
+        body = field(node2, "type").namedChildren.find((child) => child.type.endsWith("_list"));
+      }
+      if (node2.type === "impl_item") {
+        const type = field(node2, "type");
+        if (type) owner = symbols.find((symbol) => symbol.qualifiedName === type.text && ["struct", "class"].includes(symbol.kind)) ?? { qualifiedName: type.text, id: null, kind: "struct" };
+      }
+      if (kind === "function" && owner && ["class", "struct", "interface", "trait"].includes(owner.kind)) kind = "method";
+      const name = kind ? declaredName(declaration) : "";
+      if (kind && name) {
+        const qualifiedName = owner ? `${owner.qualifiedName}.${name}` : name;
+        const signature = declarationHeader(declaration, source, body?.startIndex ?? declaration.endIndex);
+        const key = `${path}#${qualifiedName}:${kind}:${hash(signature)}`;
+        const occurrence = occurrences.get(key) ?? 0;
+        occurrences.set(key, occurrence + 1);
+        const doc = documentation(declaration, body, language, source);
+        const symbol = {
+          id: `symbol:${key}:${occurrence}`,
+          kind,
+          name,
+          qualifiedName,
+          ownerId: owner?.id ?? null,
+          language,
+          path,
+          signature,
+          documentation: doc.text,
+          startLine: Math.min(doc.startLine ?? Infinity, declaration.startPosition.row + 1),
+          declarationStartLine: declaration.startPosition.row + 1,
+          endLine: lastLine(declaration),
+          bodyStartLine: body ? body.startPosition.row + 1 : null,
+          bodyEndLine: body ? lastLine(body) : null,
+          declarationStartOffset: declaration.startIndex,
+          declarationEndOffset: declaration.endIndex,
+          bodyStartOffset: body?.startIndex ?? null,
+          bodyEndOffset: body?.endIndex ?? null
+        };
+        symbols.push(symbol);
+        owner = symbol;
+      }
+      if (["import_statement", "export_statement", "import_from_statement", "use_declaration", "include_directive", "preproc_include"].includes(node2.type)) {
+        const target = field(node2, "source") ?? field(node2, "module_name") ?? field(node2, "path") ?? field(node2, "argument");
+        if (target) imports.push({ specifier: target.text.replace(/^['"]|['"]$/g, ""), line: node2.startPosition.row + 1, syntax: node2.type });
+      }
+      for (const child of node2.namedChildren) walk(child, owner);
+    };
+    tree = parser.parse(source);
+    if (!tree) throw new Error("Parser returned no syntax tree");
+    const symbols = [];
+    const imports = [];
+    const occurrences = /* @__PURE__ */ new Map();
+    walk(tree.rootNode);
+    return { symbols, imports, status: tree.rootNode.hasError ? "partial" : "parsed" };
+  } finally {
+    tree?.delete();
+    parser.delete();
+  }
+}
+var runtime, languages, field, lastLine, hash;
+var init_parser = __esm({
+  "packages/cli/src/symbols/parser.mjs"() {
+    init_runtime();
+    init_languages();
+    languages = /* @__PURE__ */ new Map();
+    field = (node2, name) => node2.childForFieldName(name);
+    lastLine = (node2) => Math.max(node2.startPosition.row + 1, node2.endPosition.row + (node2.endPosition.column ? 1 : 0));
+    hash = (text) => createHash5("sha256").update(text).digest("hex").slice(0, 16);
+  }
+});
 
 // packages/cli/src/init.mjs
 import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, statSync, writeFileSync } from "node:fs";
@@ -136,8 +890,8 @@ function sanitizeEmbeddingProfile(profile) {
   return { ...safe, ...apiKey ? { apiKey: "[redacted]" } : {} };
 }
 function embeddingProfileIdentity(profile) {
-  const { apiKey, apiKeyEnv, ...identity } = profile;
-  return identity;
+  const { apiKey, apiKeyEnv, ...identity2 } = profile;
+  return identity2;
 }
 function resolveEmbeddingProfile(root = ".", options = {}) {
   const home = options.home ?? homedir();
@@ -334,10 +1088,10 @@ function cloneReferenceExpansionPolicy(policy = {}) {
   const defaults = uniqueNormalizedTerms(lowSignal.defaults ?? DEFAULT_FUZZY_LOW_SIGNAL_TERMS);
   const add = uniqueNormalizedTerms(lowSignal.add ?? []);
   const remove = uniqueNormalizedTerms(lowSignal.remove ?? []);
-  const terms = new Set(defaults);
-  for (const term of remove) terms.delete(term);
-  for (const term of add) terms.add(term);
-  return { fuzzy: { lowSignal: { defaults, add, remove, terms: [...terms].sort() } } };
+  const terms2 = new Set(defaults);
+  for (const term of remove) terms2.delete(term);
+  for (const term of add) terms2.add(term);
+  return { fuzzy: { lowSignal: { defaults, add, remove, terms: [...terms2].sort() } } };
 }
 function normalizeReferenceExpansionPolicy(raw) {
   const lowSignal = raw?.fuzzy?.lowSignal ?? {};
@@ -481,11 +1235,11 @@ function isFiniteNumberInRange(value, min, max) {
 }
 function validateMemoryConfigData(data, root = ".", file = "dotdotgod.config.json") {
   const errors = [];
-  const add = (code, field, message, fix = null) => errors.push({
+  const add = (code, field2, message, fix = null) => errors.push({
     file: rel(root, resolve(root, file)),
     code,
-    message: `${field ? `Field "${field}": ` : ""}${message}
-Fix: ${fix ?? `update ${field ?? "this config"} in ${file} to match the expected dotdotgod config schema.`}`
+    message: `${field2 ? `Field "${field2}": ` : ""}${message}
+Fix: ${fix ?? `update ${field2 ?? "this config"} in ${file} to match the expected dotdotgod config schema.`}`
   });
   if (!data || typeof data !== "object" || Array.isArray(data)) {
     add("MEMORY_CONFIG_INVALID", null, "Config must be a JSON object.");
@@ -1306,9 +2060,9 @@ Create dotdotgod.config.json from a bundled or user template. Without --template
   dotdotgod status <root> [--json]`;
     case "query":
       return `Usage:
-  dotdotgod query <root> <query> [--limit n] [--json]
+  dotdotgod query <root> <query> [--limit n] [--scope docs|code|all] [--search hybrid|keyword|vector] [--allow-code-embedding] [--json]
 
-Search shared project documentation with the resolved local or remote embedding provider.`;
+Search full documentation and code outlines/comments. Default: hybrid docs+code. Remote code metadata requires explicit consent.`;
     case "embedding":
       return `Usage:
   dotdotgod embedding status [<root>] [--json]
@@ -1440,8 +2194,8 @@ function parseCommon(argv) {
 }
 
 // packages/cli/src/validate/run.mjs
-import { existsSync as existsSync10, readFileSync as readFileSync9, readdirSync as readdirSync2 } from "node:fs";
-import { basename as basename7, dirname as dirname6, extname as extname4, join as join8, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync13, readdirSync as readdirSync3 } from "node:fs";
+import { basename as basename7, dirname as dirname10, extname as extname6, join as join13, resolve as resolve8 } from "node:path";
 
 // packages/cli/src/docs/traceability.mjs
 import { existsSync as existsSync5 } from "node:fs";
@@ -1496,8 +2250,8 @@ function isLocalRelativeTraceabilityPath(value) {
   if (value.split("/").includes("..")) return false;
   return !isSecretIndexPath(value);
 }
-function traceabilityFieldError(file, code, field, message, line = null, config = defaultMemoryConfig()) {
-  return { file, line, code, message: `${field ? `Field "${field}": ` : ""}${message}
+function traceabilityFieldError(file, code, field2, message, line = null, config = defaultMemoryConfig()) {
+  return { file, line, code, message: `${field2 ? `Field "${field2}": ` : ""}${message}
 Fix: update the traceability block so it matches the expected schema and points to existing project files or commands.
 
 ${traceabilityExample(config)}` };
@@ -1629,13 +2383,13 @@ ${generated}
 ${suffix}`;
   return { ok: true, changed: next !== content, content: next };
 }
-function validateTraceabilityPathArray(data, field, add, root, config, { required = true, displayField = field } = {}) {
-  if (data[field] === void 0 && !required) return;
-  if (!Array.isArray(data[field])) {
+function validateTraceabilityPathArray(data, field2, add, root, config, { required = true, displayField = field2 } = {}) {
+  if (data[field2] === void 0 && !required) return;
+  if (!Array.isArray(data[field2])) {
     add("TRACEABILITY_INVALID_FIELD", displayField, "must be an array of local relative paths.");
     return;
   }
-  for (const value of data[field]) {
+  for (const value of data[field2]) {
     if (!isLocalRelativeTraceabilityPath(value)) {
       add("TRACEABILITY_INVALID_PATH", displayField, `invalid local relative path: ${JSON.stringify(value)}.`);
       continue;
@@ -1648,13 +2402,13 @@ function validateTraceabilityPathArray(data, field, add, root, config, { require
     if (!existsSync5(resolve4(root, value))) add("TRACEABILITY_MISSING_TARGET", displayField, `target does not exist: ${value}.`);
   }
 }
-function validateTraceabilityCommandArray(data, field, add, { required = true, displayField = field } = {}) {
-  if (data[field] === void 0 && !required) return;
-  if (!Array.isArray(data[field])) {
+function validateTraceabilityCommandArray(data, field2, add, { required = true, displayField = field2 } = {}) {
+  if (data[field2] === void 0 && !required) return;
+  if (!Array.isArray(data[field2])) {
     add("TRACEABILITY_INVALID_FIELD", displayField, "must be an array of executable project-local command strings.");
     return;
   }
-  for (const value of data[field]) if (typeof value !== "string" || value.trim().length === 0) add("TRACEABILITY_INVALID_COMMAND", displayField, `invalid command: ${JSON.stringify(value)}.`);
+  for (const value of data[field2]) if (typeof value !== "string" || value.trim().length === 0) add("TRACEABILITY_INVALID_COMMAND", displayField, `invalid command: ${JSON.stringify(value)}.`);
 }
 function validateConfiguredArray(data, definition, add, root, config, options) {
   if (definition.target === "command") validateTraceabilityCommandArray(data, definition.key, add, options);
@@ -1675,8 +2429,8 @@ function validateTraceabilityContracts(data, root, add, config) {
       add("TRACEABILITY_INVALID_FIELD", base, "must be an object with non-empty id and title fields.");
       continue;
     }
-    for (const field of Object.keys(contract)) {
-      if (!allowedFields.has(field)) add("TRACEABILITY_INVALID_FIELD", `${base}.${field}`, "is not a supported contract field.");
+    for (const field2 of Object.keys(contract)) {
+      if (!allowedFields.has(field2)) add("TRACEABILITY_INVALID_FIELD", `${base}.${field2}`, "is not a supported contract field.");
     }
     if (typeof contract.id !== "string" || contract.id.trim().length === 0) {
       add("TRACEABILITY_INVALID_FIELD", `${base}.id`, "must be a non-empty stable contract ID string.");
@@ -1697,7 +2451,7 @@ function validateTraceabilityContracts(data, root, add, config) {
 }
 function validateTraceabilityBlock(data, root, file, line = null, config = defaultMemoryConfig()) {
   const errors = [];
-  const add = (code, field, message) => errors.push(traceabilityFieldError(rel(root, file), code, field, message, line, config));
+  const add = (code, field2, message) => errors.push(traceabilityFieldError(rel(root, file), code, field2, message, line, config));
   if (!data || typeof data !== "object" || Array.isArray(data)) {
     add("TRACEABILITY_INVALID_JSON", null, "Traceability block must be a JSON object.");
     return errors;
@@ -1705,7 +2459,7 @@ function validateTraceabilityBlock(data, root, file, line = null, config = defau
   if (data.kind !== "spec") add("TRACEABILITY_INVALID_KIND", "kind", 'must be "spec" for behavior specs.');
   const definitions2 = traceabilityKeys(config);
   const allowedFields = /* @__PURE__ */ new Set(["kind", "contracts", ...definitions2.map((definition) => definition.key)]);
-  for (const field of Object.keys(data)) if (!allowedFields.has(field)) add("TRACEABILITY_INVALID_FIELD", field, "is not configured as a traceability field.");
+  for (const field2 of Object.keys(data)) if (!allowedFields.has(field2)) add("TRACEABILITY_INVALID_FIELD", field2, "is not configured as a traceability field.");
   for (const definition of definitions2) validateConfiguredArray(data, definition, add, root, config, { required: true, displayField: definition.key });
   validateTraceabilityContracts(data, root, add, config);
   return errors;
@@ -1932,8 +2686,8 @@ function cacheFile(root) {
 }
 
 // packages/cli/src/index/cache.mjs
-import { existsSync as existsSync9, readFileSync as readFileSync8, statSync as statSync4 } from "node:fs";
-import { basename as basename6, join as join7 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync12, statSync as statSync4 } from "node:fs";
+import { basename as basename6, join as join12 } from "node:path";
 
 // packages/cli/src/graph/store.mjs
 import { existsSync as existsSync7, mkdirSync as mkdirSync2, statSync as statSync3, writeFileSync as writeFileSync2 } from "node:fs";
@@ -2231,6 +2985,290 @@ function buildGraph(root, files, config = defaultMemoryConfig()) {
   return graph;
 }
 
+// packages/cli/src/symbols/store.mjs
+import { existsSync as existsSync11, lstatSync as lstatSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync11, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { dirname as dirname7, join as join11 } from "node:path";
+
+// packages/cli/src/symbols/discovery.mjs
+var import_ignore = __toESM(require_ignore(), 1);
+import { existsSync as existsSync10, lstatSync, readFileSync as readFileSync10, realpathSync } from "node:fs";
+import { extname as extname5, join as join9, relative as relative4, isAbsolute } from "node:path";
+
+// packages/cli/src/query/chunks.mjs
+import { readFileSync as readFileSync8, readdirSync as readdirSync2 } from "node:fs";
+import { join as join7, relative as relative3 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+var MAX_CHUNK_CHARS = 1600;
+var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "coverage", ".git", ".dotdotgod"]);
+function textFingerprint(text) {
+  return createHash3("sha256").update(text).digest("hex");
+}
+function collectDocumentationMarkdown(root, exclude = ["docs/plan", "docs/archive"], documentationRoot = "docs") {
+  const docsRoot = join7(root, documentationRoot);
+  const files = [];
+  const walk = (directory) => {
+    let entries;
+    try {
+      entries = readdirSync2(directory, { withFileTypes: true, encoding: "utf8" });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const absolute = join7(directory, entry.name);
+      const path = relative3(root, absolute).replaceAll("\\", "/");
+      if (isSecretLikePathPattern(path) || exclude.some((pattern) => matchPathPattern(path, pattern) || path === pattern || path.startsWith(`${pattern}/`))) continue;
+      if (entry.isDirectory()) {
+        if (!SKIPPED_DIRECTORIES.has(entry.name)) walk(absolute);
+      } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) files.push(path);
+    }
+  };
+  walk(docsRoot);
+  return files.sort();
+}
+function splitSection(text, maxChars = MAX_CHUNK_CHARS) {
+  if (text.length <= maxChars) return [text];
+  const paragraphs = text.split(/\n\s*\n/);
+  const chunks = [];
+  let current = "";
+  for (const paragraph of paragraphs) {
+    if (current && current.length + paragraph.length + 2 > maxChars) {
+      chunks.push(current.trim());
+      current = "";
+    }
+    if (paragraph.length > maxChars) {
+      for (let offset = 0; offset < paragraph.length; offset += maxChars) chunks.push(paragraph.slice(offset, offset + maxChars).trim());
+    } else current += `${current ? "\n\n" : ""}${paragraph}`;
+  }
+  if (current.trim()) chunks.push(current.trim());
+  return chunks.filter(Boolean);
+}
+function chunkMarkdown(path, content, maxChars = MAX_CHUNK_CHARS) {
+  const lines = content.split("\n");
+  const sections = [];
+  let headings = [];
+  let body = [];
+  const flush = () => {
+    const text = body.join("\n").trim();
+    if (!text && headings.length === 0) return;
+    const heading = headings.length > 0 ? headings.join(" > ") : path;
+    const pieces = splitSection(text || heading, maxChars);
+    pieces.forEach((piece, index) => {
+      const passage = `Path: ${path}
+Section: ${heading}
+
+${piece}`;
+      const fingerprint2 = textFingerprint(passage);
+      sections.push({ id: `${path}#${fingerprint2.slice(0, 16)}`, path, heading, part: index + 1, text: piece, passage, fingerprint: fingerprint2 });
+    });
+  };
+  for (const line of lines) {
+    const match = /^(#{1,6})\s+(.+?)\s*$/.exec(line);
+    if (!match) {
+      body.push(line);
+      continue;
+    }
+    flush();
+    body = [];
+    const level = match[1].length;
+    headings = [...headings.slice(0, level - 1), match[2]];
+  }
+  flush();
+  return sections;
+}
+function collectDocumentationChunks(root, exclude, documentationRoot = "docs") {
+  return collectDocumentationMarkdown(root, exclude, documentationRoot).flatMap((path) => {
+    const content = readFileSync8(join7(root, path), "utf8");
+    return chunkMarkdown(path, content);
+  });
+}
+
+// packages/cli/src/symbols/discovery.mjs
+init_languages();
+init_runtime();
+function inside(root, file) {
+  if (!lstatSync(file).isFile()) return false;
+  const path = relative4(realpathSync(root), realpathSync(file));
+  return !path.startsWith("..") && !isAbsolute(path);
+}
+function ignoreRules(root, directory, cache) {
+  if (!cache.has(directory)) {
+    const file = join9(root, directory, ".gitignore");
+    cache.set(directory, (0, import_ignore.default)().add(existsSync10(file) && inside(root, file) ? readFileSync10(file, "utf8") : ""));
+  }
+  return cache.get(directory);
+}
+function ignored(root, path, cache) {
+  const parts = path.split("/");
+  let excluded = false;
+  for (let depth = 0; depth < parts.length; depth += 1) {
+    const directory = parts.slice(0, depth).join("/");
+    const remaining = parts.slice(depth).join("/");
+    const rules = ignoreRules(root, directory, cache);
+    for (let end = 1; end < parts.length - depth; end += 1) {
+      if (rules.ignores(parts.slice(depth, depth + end).join("/") + "/")) return true;
+    }
+    const result = rules.test(remaining);
+    if (result.ignored) excluded = true;
+    else if (result.unignored) excluded = false;
+  }
+  return excluded;
+}
+function sourceFiles(root) {
+  const cache = /* @__PURE__ */ new Map();
+  return collectIndexFiles(root).filter((file) => {
+    const path = relative4(root, file).replaceAll("\\", "/");
+    if (!SOURCE_EXTENSIONS.has(extname5(path)) || path.split("/").some((part) => part.startsWith(".")) || isSecretLikePathPattern(path)) return false;
+    if (!inside(root, file) || ignored(root, path, cache)) return false;
+    return !/^#![^\n]*\n\/\/ Generated|^\/\/ Generated|@generated/m.test(readFileSync10(file, "utf8").slice(0, 256));
+  }).map((file) => {
+    const source = readFileSync10(file, "utf8");
+    return { path: relative4(root, file).replaceAll("\\", "/"), hash: fingerprint(file), language: languageForPath(file), sourceLength: source.length, lineCount: source.split("\n").length };
+  });
+}
+function outlinePolicy(root) {
+  const config = readMemoryConfig(root);
+  const ignores = collectIndexFiles(root).filter((file) => file.endsWith("/.gitignore") && inside(root, file)).map((file) => [relative4(root, file), fingerprint(file)]);
+  return textFingerprint(JSON.stringify({ areas: config.areas, ignores, extractor: EXTRACTOR_ID, declarations: DECLARATIONS, extensions: LANGUAGE_EXTENSIONS, parser: parserIdentity() }));
+}
+
+// packages/cli/src/symbols/store.mjs
+init_languages();
+var OUTLINE_SCHEMA = 1;
+var outlinePath = (root) => join11(root, ".dotdotgod", "outlines.json");
+function assertCachePath(root) {
+  for (const path of [dirname7(outlinePath(root)), outlinePath(root)]) {
+    let stat;
+    try {
+      stat = lstatSync2(path);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    if (stat?.isSymbolicLink()) throw new Error(`Outline cache must not use symlinks: ${path}`);
+  }
+}
+function readOutlines(root) {
+  try {
+    assertCachePath(root);
+    const index = JSON.parse(readFileSync11(outlinePath(root), "utf8"));
+    if (index.schema !== OUTLINE_SCHEMA || index.extractor !== EXTRACTOR_ID || !Array.isArray(index.files)) return null;
+    const paths = /* @__PURE__ */ new Set();
+    const ids = /* @__PURE__ */ new Set();
+    for (const file of index.files) {
+      if (typeof file.path !== "string" || file.path.startsWith("/") || file.path.split("/").includes("..") || paths.has(file.path) || !/^[a-f0-9]{64}$/.test(file.hash)) return null;
+      if (!Number.isInteger(file.sourceLength) || file.sourceLength < 0 || !Number.isInteger(file.lineCount) || file.lineCount < 1) return null;
+      if (file.language !== languageForPath(file.path) || file.language === null !== (file.status === "unsupported")) return null;
+      paths.add(file.path);
+      if (!["parsed", "partial", "unsupported", "failed"].includes(file.status) || !Array.isArray(file.symbols) || !Array.isArray(file.imports)) return null;
+      if (file.imports.some((item) => typeof item.specifier !== "string" || !Number.isInteger(item.line) || item.line < 1)) return null;
+      for (const symbol of file.symbols) {
+        if (symbol.path !== file.path || typeof symbol.id !== "string" || !symbol.id.startsWith(`symbol:${file.path}#`) || ids.has(symbol.id) || typeof symbol.signature !== "string" || typeof symbol.documentation !== "string") return null;
+        if (!Number.isInteger(symbol.startLine) || !Number.isInteger(symbol.endLine) || symbol.startLine < 1 || symbol.endLine < symbol.startLine || symbol.endLine > file.lineCount) return null;
+        if (typeof symbol.name !== "string" || typeof symbol.qualifiedName !== "string" || !Number.isInteger(symbol.declarationStartLine) || symbol.declarationStartLine < symbol.startLine || symbol.declarationStartLine > symbol.endLine) return null;
+        if (symbol.bodyStartLine === null !== (symbol.bodyEndLine === null)) return null;
+        if (symbol.bodyStartLine !== null && (!Number.isInteger(symbol.bodyStartLine) || !Number.isInteger(symbol.bodyEndLine) || symbol.bodyStartLine < symbol.declarationStartLine || symbol.bodyEndLine > symbol.endLine || symbol.bodyEndLine < symbol.bodyStartLine)) return null;
+        if (!Number.isInteger(symbol.declarationStartOffset) || !Number.isInteger(symbol.declarationEndOffset) || symbol.declarationStartOffset < 0 || symbol.declarationEndOffset < symbol.declarationStartOffset || symbol.declarationEndOffset > file.sourceLength) return null;
+        if (symbol.bodyStartOffset === null !== (symbol.bodyEndOffset === null)) return null;
+        if (symbol.bodyStartOffset !== null && (!Number.isInteger(symbol.bodyStartOffset) || !Number.isInteger(symbol.bodyEndOffset) || symbol.bodyStartOffset < symbol.declarationStartOffset || symbol.bodyEndOffset > symbol.declarationEndOffset || symbol.bodyEndOffset < symbol.bodyStartOffset)) return null;
+        ids.add(symbol.id);
+      }
+    }
+    for (const file of index.files) for (const symbol of file.symbols) if (symbol.ownerId !== null && !ids.has(symbol.ownerId)) return null;
+    return index;
+  } catch {
+    return null;
+  }
+}
+function outlineStatus(root) {
+  assertCachePath(root);
+  const files = sourceFiles(root);
+  const index = readOutlines(root);
+  if (!index) return { ok: files.length === 0 && !existsSync11(outlinePath(root)), reason: existsSync11(outlinePath(root)) ? "missing-or-invalid" : "missing", paths: files.map((file) => file.path) };
+  const old = new Map(index.files.map((file) => [file.path, file]));
+  const current = new Set(files.map((file) => file.path));
+  const changed = files.filter((file) => old.get(file.path)?.hash !== file.hash || old.get(file.path)?.sourceLength !== file.sourceLength || old.get(file.path)?.lineCount !== file.lineCount).map((file) => file.path);
+  const removed = [...old.keys()].filter((path) => !current.has(path));
+  const failures = index.files.filter((file) => ["failed", "partial"].includes(file.status)).map((file) => file.path);
+  const policyOk = index.policy === outlinePolicy(root);
+  return { ok: policyOk && !changed.length && !removed.length && !failures.length, reason: !policyOk ? "policy-changed" : failures.length ? "extraction-incomplete" : changed.length || removed.length ? "source-changed" : "fresh", paths: [.../* @__PURE__ */ new Set([...changed, ...removed, ...failures])], unsupported: index.files.filter((file) => file.status === "unsupported").map((file) => file.path) };
+}
+async function buildOutlines(root) {
+  assertCachePath(root);
+  const files = sourceFiles(root);
+  const old = readOutlines(root);
+  const previous = new Map(old?.policy === outlinePolicy(root) ? old.files.map((file) => [file.path, file]) : []);
+  let parsed = 0;
+  let reused = 0;
+  const records = [];
+  for (const file of files) {
+    const cached = previous.get(file.path);
+    if (cached?.hash === file.hash && ["parsed", "unsupported"].includes(cached.status)) {
+      records.push(cached);
+      reused += 1;
+      continue;
+    }
+    if (!file.language) {
+      records.push({ ...file, status: "unsupported", symbols: [], imports: [] });
+      continue;
+    }
+    const { extractSymbols: extractSymbols2 } = await Promise.resolve().then(() => (init_parser(), parser_exports));
+    const source = readFileSync11(join11(root, file.path), "utf8");
+    const extracted = await extractSymbols2(file.path, source, file.language);
+    if (fingerprint(join11(root, file.path)) !== file.hash) throw new Error(`Source changed during outline extraction: ${file.path}`);
+    records.push({ ...file, ...extracted });
+    parsed += 1;
+  }
+  const index = { schema: OUTLINE_SCHEMA, extractor: EXTRACTOR_ID, policy: outlinePolicy(root), files: records, refresh: { parsed, reused } };
+  const target = outlinePath(root);
+  mkdirSync3(dirname7(target), { recursive: true });
+  const temporary = `${target}.tmp-${process.pid}-${randomUUID()}`;
+  writeFileSync3(temporary, JSON.stringify(index), { flag: "wx" });
+  renameSync(temporary, target);
+  return index;
+}
+function outlineChunks(index) {
+  return index.files.flatMap((file) => file.symbols.map((symbol) => {
+    const text = `${symbol.signature}
+${symbol.documentation}`.trim();
+    const passage = `Path: ${file.path}
+Symbol: ${symbol.qualifiedName}
+Kind: ${symbol.kind}
+
+${text}`;
+    return { ...symbol, kind: "symbol", symbolKind: symbol.kind, heading: symbol.qualifiedName, text, passage, sourceHash: file.hash, fingerprint: textFingerprint(passage) };
+  }));
+}
+
+// packages/cli/src/symbols/graph.mjs
+import { dirname as dirname8, posix } from "node:path";
+function importTarget(file, specifier, paths) {
+  if (!specifier.startsWith(".")) return null;
+  const base = posix.normalize(posix.join(dirname8(file).replaceAll("\\", "/"), specifier));
+  if (base.startsWith("../")) return null;
+  const stem = base.replace(/\.(js|jsx|mjs|cjs)$/, "");
+  const candidates = [base, ...[".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py"].map((extension) => `${stem}${extension}`), ...[".ts", ".js", ".py"].map((extension) => `${base}/index${extension}`)];
+  return candidates.find((path) => paths.has(path)) ?? null;
+}
+function addOutlineGraph(graph, index) {
+  const paths = new Set(index.files.map((file) => file.path));
+  for (const file of index.files) {
+    const source = `file:${file.path}`;
+    for (const symbol of file.symbols) {
+      addNode(graph, symbol.id, "symbol", { ...symbol, sourceHash: file.hash });
+      addEdge(graph, symbol.ownerId ?? source, symbol.id, symbol.ownerId ? "contains_symbol" : "declares_symbol", { confidence: "PARSED", path: file.path });
+    }
+    for (const item of file.imports) {
+      const resolved = importTarget(file.path, item.specifier, paths);
+      const target = resolved ? `file:${resolved}` : `import:${file.path}#${item.specifier}`;
+      if (!resolved) addNode(graph, target, "unresolved_import", { path: file.path, specifier: item.specifier });
+      addEdge(graph, source, target, "imports", { ...item, resolved: Boolean(resolved), confidence: resolved ? "RESOLVED_RELATIVE_FILE" : "SYNTAX_ONLY", path: file.path });
+    }
+  }
+  return graph;
+}
+
 // packages/cli/src/index/cache.mjs
 function collectFingerprints(root, config = readMemoryConfig(root)) {
   return collectIndexFiles(root, config).map((file) => {
@@ -2261,11 +3299,23 @@ function buildIndex(root, previous = readIndex(root)) {
   const currentPaths = new Set(files.map((file) => file.path));
   const removedPaths = (previous?.files ?? []).filter((file) => !currentPaths.has(file.path)).map((file) => file.path);
   const changedPaths = [...files.filter((file) => indexed.get(file.path) !== file.sha256).map((file) => file.path), ...removedPaths];
-  const changedFiles = files.filter((file) => changedPaths.includes(file.path)).map((file) => join7(root, file.path));
+  const changedFiles = files.filter((file) => changedPaths.includes(file.path)).map((file) => join12(root, file.path));
   const fullRebuild = !previous?.graph || previous.version !== CACHE_VERSION;
   const refreshReason = !previous ? "missing" : previous.version !== CACHE_VERSION ? "schema-mismatch" : removedPaths.length > 0 ? "content-removed" : changedPaths.length > 0 ? "content-changed" : "fresh";
-  const rawGraph = fullRebuild ? buildGraph(root, files.map((file) => join7(root, file.path)), memoryConfig) : mergeIncrementalGraph(previous.graph, buildGraph(root, changedFiles, memoryConfig), changedPaths);
-  const graph = rawGraph;
+  const rawGraph = fullRebuild ? buildGraph(root, files.map((file) => join12(root, file.path)), memoryConfig) : mergeIncrementalGraph(previous.graph, buildGraph(root, changedFiles, memoryConfig), changedPaths);
+  const graph = { nodes: rawGraph.nodes.filter((node2) => !["symbol", "unresolved_import"].includes(node2.type)), edges: rawGraph.edges.filter((edge) => !["declares_symbol", "contains_symbol", "imports"].includes(edge.relation)) };
+  const outlines = readOutlines(root);
+  let outlinePolicyMatches = false;
+  if (outlines) {
+    try {
+      outlinePolicyMatches = outlines.policy === outlinePolicy(root);
+    } catch {
+    }
+  }
+  if (outlinePolicyMatches) {
+    const hashes = new Map(files.map((file) => [file.path, file.sha256]));
+    addOutlineGraph(graph, { files: outlines.files.filter((file) => hashes.get(file.path) === file.hash && file.status === "parsed") });
+  }
   const archiveBodiesIncluded = (memoryConfig.areas ?? []).some((area2) => area2.id === "archive-body" && area2.includeBodiesByDefault !== false);
   return { version: CACHE_VERSION, schemaVersion: CACHE_VERSION, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), archiveBodiesIncluded, memoryConfig: memoryConfigSummary(memoryConfig), files, graph, stats: graphStats(graph), incremental: { enabled: true, fullRebuild, changedFiles: changedPaths.length, refreshReason, elapsedMs: Date.now() - startedAt } };
 }
@@ -2276,20 +3326,20 @@ function writeIndex(root, index) {
   const graphShards = { nodes: Object.fromEntries(Object.keys(compact.nodes).map((name) => [name, rel(root, shardFile(root, "nodes", name))])), edges: Object.fromEntries(Object.keys(compact.edges).map((name) => [name, rel(root, shardFile(root, "edges", name))])) };
   const manifest = { version: index.version, schemaVersion: index.schemaVersion ?? index.version, generatedAt: index.generatedAt, archiveBodiesIncluded: index.archiveBodiesIncluded, memoryConfig: index.memoryConfig, files: index.files, graph: { ...graphStats(index.graph), compactSchema: true, shards: graphShards }, incremental: index.incremental };
   writeJson(cacheFile(root), manifest);
-  const shardBytes = [...Object.values(graphShards.nodes), ...Object.values(graphShards.edges)].reduce((sum, path) => sum + jsonSize(join7(root, path)), 0);
+  const shardBytes = [...Object.values(graphShards.nodes), ...Object.values(graphShards.edges)].reduce((sum, path) => sum + jsonSize(join12(root, path)), 0);
   const manifestBytes = jsonSize(cacheFile(root));
   return { ...manifest, indexSizeBytes: manifestBytes + shardBytes, manifestBytes, shardBytes };
 }
 function readIndex(root) {
   const file = cacheFile(root);
-  if (!existsSync9(file)) return null;
+  if (!existsSync12(file)) return null;
   try {
-    const manifest = JSON.parse(readFileSync8(file, "utf8"));
+    const manifest = JSON.parse(readFileSync12(file, "utf8"));
     const shards = manifest.graph?.shards;
     if (!shards) return manifest;
     const compact = { nodes: {}, edges: {} };
-    for (const [name, path] of Object.entries(shards.nodes ?? {})) compact.nodes[name] = existsSync9(join7(root, path)) ? JSON.parse(readFileSync8(join7(root, path), "utf8")) : [];
-    for (const [name, path] of Object.entries(shards.edges ?? {})) compact.edges[name] = existsSync9(join7(root, path)) ? JSON.parse(readFileSync8(join7(root, path), "utf8")) : [];
+    for (const [name, path] of Object.entries(shards.nodes ?? {})) compact.nodes[name] = existsSync12(join12(root, path)) ? JSON.parse(readFileSync12(join12(root, path), "utf8")) : [];
+    for (const [name, path] of Object.entries(shards.edges ?? {})) compact.edges[name] = existsSync12(join12(root, path)) ? JSON.parse(readFileSync12(join12(root, path), "utf8")) : [];
     return { ...manifest, graph: expandGraph(compact) };
   } catch {
     return null;
@@ -2311,11 +3361,12 @@ function getStatus(root) {
   const reason = ok ? "fresh" : !schemaOk ? "schema-mismatch" : staleFiles.length > 0 ? "content-changed" : "unknown";
   return { ok, status: ok ? "fresh" : "stale", cachePath: rel(root, cacheFile(root)), indexedFiles: index.files?.length ?? 0, currentFiles: currentFiles.length, staleFiles: staleFiles.length, examples: staleFiles.slice(0, 10), archiveBodiesIncluded: index.archiveBodiesIncluded === true, schemaVersion, expectedSchemaVersion: CACHE_VERSION, schemaOk, reason, graph: graphStats(index.graph ?? { nodes: [], edges: [] }) };
 }
-function runIndex(argv) {
+async function runIndex(argv) {
   const options = parseCommon(argv);
+  const outlines = await buildOutlines(options.root);
   const index = buildIndex(options.root);
   const manifest = writeIndex(options.root, index);
-  const result = { ok: true, cachePath: rel(options.root, cacheFile(options.root)), schemaVersion: CACHE_VERSION, indexedFiles: index.files.length, nodes: index.graph.nodes.length, edges: index.graph.edges.length, indexSizeBytes: manifest.indexSizeBytes, shards: manifest.graph.shards, incremental: index.incremental, archiveBodiesIncluded: index.archiveBodiesIncluded === true, memoryConfig: index.memoryConfig };
+  const result = { ok: true, cachePath: rel(options.root, cacheFile(options.root)), schemaVersion: CACHE_VERSION, indexedFiles: index.files.length, outlines: { refresh: outlines.refresh, unsupported: outlines.files.filter((file) => file.status === "unsupported").map((file) => file.path), partial: outlines.files.filter((file) => file.status === "partial").map((file) => file.path) }, nodes: index.graph.nodes.length, edges: index.graph.edges.length, indexSizeBytes: manifest.indexSizeBytes, shards: manifest.graph.shards, incremental: index.incremental, archiveBodiesIncluded: index.archiveBodiesIncluded === true, memoryConfig: index.memoryConfig };
   if (options.json) console.log(JSON.stringify(result, null, 2));
   else console.log(`\u2705 index written (${result.indexedFiles} files, ${result.nodes} nodes, ${result.edges} edges, ${(result.indexSizeBytes / 1024).toFixed(1)} KiB, cache: ${result.cachePath})`);
 }
@@ -2344,7 +3395,7 @@ function graphSummary(index) {
 
 // packages/cli/src/validate/references.mjs
 import { statSync as statSync5 } from "node:fs";
-import { dirname as dirname5, relative as relative3, resolve as resolve7 } from "node:path";
+import { dirname as dirname9, relative as relative5, resolve as resolve7 } from "node:path";
 var blank = (text) => text.replace(/[^\n\r]/g, " ");
 var unescape = (text) => text.replace(/\\([!"#$%&'()*+,\-./:;<=>?@[\]\\^_`{|}~])/g, "$1");
 var labelKey = (text) => unescape(text).trim().replace(/\s+/g, " ").toLowerCase();
@@ -2444,7 +3495,7 @@ function extractMemoryReferences(content) {
   return references;
 }
 function sharedLocalReferences(content, root, file, config) {
-  const source = resolveMemoryArea(relative3(root, file).split("\\").join("/"), config);
+  const source = resolveMemoryArea(relative5(root, file).split("\\").join("/"), config);
   if (source?.scope !== "shared") return [];
   const errors = [];
   for (const item of extractMemoryReferences(content)) {
@@ -2456,8 +3507,8 @@ function sharedLocalReferences(content, root, file, config) {
       continue;
     }
     if (!path) continue;
-    const base = item.kind === "markdown-link" || /^\.\.?\//.test(path) ? dirname5(file) : root;
-    const target = relative3(root, resolve7(base, path)).split("\\").join("/");
+    const base = item.kind === "markdown-link" || /^\.\.?\//.test(path) ? dirname9(file) : root;
+    const target = relative5(root, resolve7(base, path)).split("\\").join("/");
     if (target === ".." || target.startsWith("../")) continue;
     if (item.kind === "inline-code") {
       const configuredDirectory = (config.areas ?? []).some((area3) => (area3.paths ?? []).some((pattern) => pattern === `${target}/**`));
@@ -2491,7 +3542,7 @@ function runValidate(argv) {
   const root = resolve8(options.root);
   const memoryConfig = readMemoryConfig(root);
   const documentationRoot = memoryConfig.documentation?.root ?? "docs";
-  const docs = join8(root, documentationRoot);
+  const docs = join13(root, documentationRoot);
   const errors = [];
   const warnings = [];
   const markdownFiles = [];
@@ -2509,9 +3560,9 @@ Fix: ${fix}` : message, ...prompt ? { prompt } : {} });
     return false;
   };
   const walk = (dir) => {
-    if (!existsSync10(dir) || shouldSkipDir(dir)) return;
-    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-      const path = join8(dir, entry.name);
+    if (!existsSync13(dir) || shouldSkipDir(dir)) return;
+    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+      const path = join13(dir, entry.name);
       if (entry.isDirectory()) {
         const docsRel = rel(docs, path);
         if (docsRel && !docsRel.startsWith("..")) {
@@ -2521,7 +3572,7 @@ Fix: ${fix}` : message, ...prompt ? { prompt } : {} });
       } else if (entry.isFile() && entry.name.endsWith(".md")) markdownFiles.push(path);
     }
   };
-  if (!existsSync10(docs)) usage(`docs directory not found: ${docs}`);
+  if (!existsSync13(docs)) usage(`docs directory not found: ${docs}`);
   const validationPolicy = cloneValidationPolicy(memoryConfig.validation ?? DEFAULT_VALIDATION_POLICY);
   const maxLines = options.maxLines ?? validationPolicy.markdown.maxLines;
   const maxChars = options.maxChars ?? validationPolicy.markdown.maxChars;
@@ -2552,7 +3603,7 @@ README.md directory indexes, clear HTTP-status filenames such as RESPONSE_200_OK
   walk(docs);
   const dirSiblingMap = /* @__PURE__ */ new Map();
   for (const f of markdownFiles) {
-    const dir = dirname6(f);
+    const dir = dirname10(f);
     if (!dirSiblingMap.has(dir)) dirSiblingMap.set(dir, []);
     dirSiblingMap.get(dir).push(basename7(f));
   }
@@ -2561,14 +3612,14 @@ README.md directory indexes, clear HTTP-status filenames such as RESPONSE_200_OK
     const docsRel = rel(docs, file);
     const rootRel = rel(root, file);
     if (docsRel && !docsRel.startsWith("..") && !isUpperSnakeMarkdown(name)) addError(file, "FILE_NAMING", `Markdown file must be UPPER_SNAKE_CASE.md or README.md: ${name}`, null, "rename the markdown file to UPPER_SNAKE_CASE.md or README.md and update any links that reference it.");
-    const content = readFileSync9(file, "utf8");
+    const content = readFileSync13(file, "utf8");
     fileCache.set(file, content);
     const docArea = docsRel?.split("/")[0];
     if (name !== "README.md" && isUpperSnakeMarkdown(name) && FILENAME_QUALITY_AREAS.has(docArea)) {
       const fp = validationPolicy.markdown?.filename ?? {};
       const allow = fp.allow ?? [];
       if (!allow.some((p) => matchPathPattern(rootRel, p)) && (fp.warnNumberedSeries ?? true)) {
-        const siblings = dirSiblingMap.get(dirname6(file)) ?? [];
+        const siblings = dirSiblingMap.get(dirname10(file)) ?? [];
         if (isNumberedSeriesFilename(name, siblings)) {
           const heading = extractFirstHeading(content);
           const suggestion = suggestFilenameFromHeading(heading);
@@ -2610,7 +3661,7 @@ ${traceabilityExample()}`, block.line);
     }
   }
   const byDir = /* @__PURE__ */ new Map();
-  for (const file of markdownFiles) byDir.set(dirname6(file), [...byDir.get(dirname6(file)) ?? [], file]);
+  for (const file of markdownFiles) byDir.set(dirname10(file), [...byDir.get(dirname10(file)) ?? [], file]);
   for (const [dir, files] of byDir) {
     if (files.length > 1 && !files.some((file) => basename7(file) === "README.md")) addError(dir, "MISSING_README", "Directory with multiple markdown files must include README.md", null, "add a README.md in this directory that indexes the important markdown files and their purpose.");
   }
@@ -2621,24 +3672,32 @@ ${traceabilityExample()}`, block.line);
   }
   if (options.linkCheck) {
     for (const [file, content] of fileCache) {
-      const fileDir = dirname6(file);
+      const fileDir = dirname10(file);
       for (const { href, line } of extractLinks(content)) {
         const hashIndex = href.indexOf("#");
         const pathPart = hashIndex === -1 ? href : href.slice(0, hashIndex);
         const anchor = hashIndex === -1 ? "" : href.slice(hashIndex + 1);
         const target = pathPart ? resolve8(fileDir, pathPart) : file;
-        if (pathPart && !existsSync10(target)) {
+        if (pathPart && !existsSync13(target)) {
           addError(file, "BROKEN_LINK", `Local link target does not exist: ${pathPart}`, line, "update the link target to an existing local file, create the intended file, or remove the stale link.");
           continue;
         }
-        if (anchor && extname4(target) === ".md") {
-          const targetContent = fileCache.get(target) ?? (existsSync10(target) ? readFileSync9(target, "utf8") : "");
+        if (anchor && extname6(target) === ".md") {
+          const targetContent = fileCache.get(target) ?? (existsSync13(target) ? readFileSync13(target, "utf8") : "");
           if (targetContent && !extractAnchors(targetContent).has(decodeURIComponent(anchor))) addError(file, "BROKEN_ANCHOR", `Local anchor target does not exist: ${href}`, line, "update the fragment to a heading that exists in the target markdown file, or add the missing heading.");
         }
       }
     }
   }
   if (options.checkIndex) {
+    let outlines;
+    try {
+      outlines = outlineStatus(root);
+    } catch (error) {
+      outlines = { ok: false, reason: `inspection-unavailable: ${error instanceof Error ? error.message : String(error)}`, paths: [] };
+    }
+    if (!outlines.ok) addError(outlinePath(root), "OUTLINE_INDEX_STALE", `Outline index: ${outlines.reason}${outlines.paths.length ? ` (${outlines.paths.join(", ")})` : ""}`, null, "run `dotdotgod index <root>` to refresh outlines and graph metadata; validation does not parse, embed or repair.");
+    for (const path of outlines.unsupported ?? []) addWarning(join13(root, path), "OUTLINE_LANGUAGE_UNSUPPORTED", "Source language is not supported by the current outline extraction matrix.");
     const index = readIndex(root);
     if (!index) addError(cacheFile(root), "INDEX_MISSING", "Expected .dotdotgod index cache.", null, "run `dotdotgod index <root>` to build the graph index.");
     else {
@@ -2658,20 +3717,20 @@ ${traceabilityExample()}`, block.line);
   }
   if (options.includeLocalMemory) {
     for (const area2 of ["plan", "archive/plan", "archive/report"]) {
-      const areaRoot = join8(docs, area2);
-      if (!existsSync10(areaRoot)) continue;
-      for (const entry of readdirSync2(areaRoot, { withFileTypes: true })) {
+      const areaRoot = join13(docs, area2);
+      if (!existsSync13(areaRoot)) continue;
+      for (const entry of readdirSync3(areaRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        if (!isKebabCase(entry.name)) addError(join8(areaRoot, entry.name), "SLUG_NAMING", `Archive/plan/report slug must be kebab-case: ${entry.name}`, null, "rename the task/report directory to kebab-case and update any README index links that reference it.");
-        const readme = join8(areaRoot, entry.name, "README.md");
-        if (!existsSync10(readme)) addError(readme, "MISSING_README", `Expected README.md in ${documentationRoot}/${area2}/${entry.name}/`, null, "add a README.md that summarizes the task/report and links any supporting files.");
+        if (!isKebabCase(entry.name)) addError(join13(areaRoot, entry.name), "SLUG_NAMING", `Archive/plan/report slug must be kebab-case: ${entry.name}`, null, "rename the task/report directory to kebab-case and update any README index links that reference it.");
+        const readme = join13(areaRoot, entry.name, "README.md");
+        if (!existsSync13(readme)) addError(readme, "MISSING_README", `Expected README.md in ${documentationRoot}/${area2}/${entry.name}/`, null, "add a README.md that summarizes the task/report and links any supporting files.");
       }
     }
   }
-  const gitignore = join8(root, ".gitignore");
-  if (!existsSync10(gitignore)) addError(gitignore, "MISSING_GITIGNORE", "Expected .gitignore", null, `create .gitignore and include ${documentationRoot}/plan, ${documentationRoot}/archive, and .dotdotgod entries.`);
+  const gitignore = join13(root, ".gitignore");
+  if (!existsSync13(gitignore)) addError(gitignore, "MISSING_GITIGNORE", "Expected .gitignore", null, `create .gitignore and include ${documentationRoot}/plan, ${documentationRoot}/archive, and .dotdotgod entries.`);
   else {
-    const content = readFileSync9(gitignore, "utf8").split("\n").map((line) => line.trim());
+    const content = readFileSync13(gitignore, "utf8").split("\n").map((line) => line.trim());
     for (const required of [`${documentationRoot}/plan`, `${documentationRoot}/archive`, CACHE_DIR]) if (!content.includes(required)) addError(gitignore, "MISSING_GITIGNORE_ENTRY", `Expected .gitignore entry: ${required}`, null, `add ${required} to .gitignore so local plans, archives, and cache files stay untracked.`);
   }
   if (options.json) console.log(JSON.stringify({ ok: errors.length === 0, errors, warnings }, null, 2));
@@ -2696,8 +3755,8 @@ Prompt: ${error.prompt}` : ""}`);
 }
 
 // packages/cli/src/commands/config.mjs
-import { existsSync as existsSync11, statSync as statSync6, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join9, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync14, statSync as statSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join14, resolve as resolve9 } from "node:path";
 function parseConfigOptions(argv, usageKey = "config") {
   const options = { root: ".", json: false, template: null };
   let rootSet = false;
@@ -2758,17 +3817,17 @@ function runConfig(argv) {
   const isInit = argv[0] === "init";
   const options = parseConfigOptions(isInit ? argv.slice(1) : argv, isInit ? "config init" : "config");
   if (isInit) {
-    if (!existsSync11(options.root)) configInitError(options, "ROOT_NOT_FOUND", `Project root not found: ${options.root}`);
+    if (!existsSync14(options.root)) configInitError(options, "ROOT_NOT_FOUND", `Project root not found: ${options.root}`);
     try {
       if (!statSync6(options.root).isDirectory()) configInitError(options, "ROOT_NOT_DIRECTORY", `Project root is not a directory: ${options.root}`);
     } catch {
       configInitError(options, "ROOT_NOT_FOUND", `Project root not found: ${options.root}`);
     }
-    const target = join9(options.root, "dotdotgod.config.json");
-    if (existsSync11(target)) configInitError(options, "CONFIG_EXISTS", "dotdotgod.config.json already exists.", target);
+    const target = join14(options.root, "dotdotgod.config.json");
+    if (existsSync14(target)) configInitError(options, "CONFIG_EXISTS", "dotdotgod.config.json already exists.", target);
     const template = resolveInitializationTemplate(options.template);
     if (!template.ok) configInitError(options, template.error.code, template.error.message, template.error.path ?? target);
-    writeFileSync3(target, template.text);
+    writeFileSync4(target, template.text);
     const payload2 = { ok: true, command: "config init", root: options.root, path: target, created: true, template: { name: template.name, source: template.source, selectedBy: template.selectedBy } };
     if (options.json) console.log(JSON.stringify(payload2, null, 2));
     else console.log(`dotdotgod config init: created ${target} from ${template.source}:${template.name} (${template.selectedBy})`);
@@ -2784,7 +3843,7 @@ function runConfig(argv) {
     errors.push({ file: "embedding config", code: "EMBEDDING_CONFIG_INVALID", message: error instanceof Error ? error.message : String(error) });
     embedding = { source: "invalid", path: null, profile: sanitizeEmbeddingProfile({ provider: "local", model: "Xenova/multilingual-e5-small" }) };
   }
-  const payload = { ok: errors.length === 0, command: "config", root: options.root, source: config.source ?? "default", path: config.source && config.source !== "default" ? join9(options.root, config.source) : null, embedding, config: memoryConfigSummary(config), errors };
+  const payload = { ok: errors.length === 0, command: "config", root: options.root, source: config.source ?? "default", path: config.source && config.source !== "default" ? join14(options.root, config.source) : null, embedding, config: memoryConfigSummary(config), errors };
   if (options.json) console.log(JSON.stringify(payload, null, 2));
   else console.log(formatConfigOutput(payload));
   if (errors.length > 0) process.exit(1);
@@ -2793,102 +3852,12 @@ function runConfig(argv) {
 // packages/cli/src/commands/query.mjs
 import { resolve as resolve10 } from "node:path";
 
-// packages/cli/src/query/chunks.mjs
-import { readFileSync as readFileSync10, readdirSync as readdirSync3 } from "node:fs";
-import { join as join10, relative as relative4 } from "node:path";
-import { createHash as createHash3 } from "node:crypto";
-var MAX_CHUNK_CHARS = 1600;
-var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "coverage", ".git", ".dotdotgod"]);
-function textFingerprint(text) {
-  return createHash3("sha256").update(text).digest("hex");
-}
-function collectDocumentationMarkdown(root, exclude = ["docs/plan", "docs/archive"], documentationRoot = "docs") {
-  const docsRoot = join10(root, documentationRoot);
-  const files = [];
-  const walk = (directory) => {
-    let entries;
-    try {
-      entries = readdirSync3(directory, { withFileTypes: true, encoding: "utf8" });
-    } catch {
-      return;
-    }
-    entries.sort((a, b) => a.name.localeCompare(b.name));
-    for (const entry of entries) {
-      if (entry.name.startsWith(".")) continue;
-      const absolute = join10(directory, entry.name);
-      const path = relative4(root, absolute).replaceAll("\\", "/");
-      if (isSecretLikePathPattern(path) || exclude.some((pattern) => matchPathPattern(path, pattern) || path === pattern || path.startsWith(`${pattern}/`))) continue;
-      if (entry.isDirectory()) {
-        if (!SKIPPED_DIRECTORIES.has(entry.name)) walk(absolute);
-      } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) files.push(path);
-    }
-  };
-  walk(docsRoot);
-  return files.sort();
-}
-function splitSection(text, maxChars = MAX_CHUNK_CHARS) {
-  if (text.length <= maxChars) return [text];
-  const paragraphs = text.split(/\n\s*\n/);
-  const chunks = [];
-  let current = "";
-  for (const paragraph of paragraphs) {
-    if (current && current.length + paragraph.length + 2 > maxChars) {
-      chunks.push(current.trim());
-      current = "";
-    }
-    if (paragraph.length > maxChars) {
-      for (let offset = 0; offset < paragraph.length; offset += maxChars) chunks.push(paragraph.slice(offset, offset + maxChars).trim());
-    } else current += `${current ? "\n\n" : ""}${paragraph}`;
-  }
-  if (current.trim()) chunks.push(current.trim());
-  return chunks.filter(Boolean);
-}
-function chunkMarkdown(path, content, maxChars = MAX_CHUNK_CHARS) {
-  const lines = content.split("\n");
-  const sections = [];
-  let headings = [];
-  let body = [];
-  const flush = () => {
-    const text = body.join("\n").trim();
-    if (!text && headings.length === 0) return;
-    const heading = headings.length > 0 ? headings.join(" > ") : path;
-    const pieces = splitSection(text || heading, maxChars);
-    pieces.forEach((piece, index) => {
-      const passage = `Path: ${path}
-Section: ${heading}
-
-${piece}`;
-      const fingerprint2 = textFingerprint(passage);
-      sections.push({ id: `${path}#${fingerprint2.slice(0, 16)}`, path, heading, part: index + 1, text: piece, passage, fingerprint: fingerprint2 });
-    });
-  };
-  for (const line of lines) {
-    const match = /^(#{1,6})\s+(.+?)\s*$/.exec(line);
-    if (!match) {
-      body.push(line);
-      continue;
-    }
-    flush();
-    body = [];
-    const level = match[1].length;
-    headings = [...headings.slice(0, level - 1), match[2]];
-  }
-  flush();
-  return sections;
-}
-function collectDocumentationChunks(root, exclude, documentationRoot = "docs") {
-  return collectDocumentationMarkdown(root, exclude, documentationRoot).flatMap((path) => {
-    const content = readFileSync10(join10(root, path), "utf8");
-    return chunkMarkdown(path, content);
-  });
-}
-
 // packages/cli/src/query/embedding-runtime.mjs
-import { existsSync as existsSync12, mkdirSync as mkdirSync3, readFileSync as readFileSync11, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync4, readFileSync as readFileSync14, rmSync, writeFileSync as writeFileSync5 } from "node:fs";
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 import { homedir as homedir3 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join15 } from "node:path";
 import { pathToFileURL } from "node:url";
 var EMBEDDING_RUNTIME_PACKAGE = "@huggingface/transformers";
 var EMBEDDING_RUNTIME_VERSION = "4.2.0";
@@ -2900,13 +3869,13 @@ var EmbeddingRuntimeMissingError = class extends Error {
   }
 };
 function embeddingRuntimeRoot(options = {}) {
-  return join11(options.home ?? homedir3(), ".dotdotgod", "runtime", "embedding");
+  return join15(options.home ?? homedir3(), ".dotdotgod", "runtime", "embedding");
 }
 function resolvePersistentTransformers(options = {}) {
   const root = embeddingRuntimeRoot(options);
   try {
-    const require2 = createRequire(join11(root, "package.json"));
-    return require2.resolve(EMBEDDING_RUNTIME_PACKAGE);
+    const require3 = createRequire2(join15(root, "package.json"));
+    return require3.resolve(EMBEDDING_RUNTIME_PACKAGE);
   } catch {
     throw new EmbeddingRuntimeMissingError();
   }
@@ -2914,10 +3883,10 @@ function resolvePersistentTransformers(options = {}) {
 function embeddingRuntimeStatus(options = {}) {
   const root = embeddingRuntimeRoot(options);
   try {
-    const require2 = createRequire(join11(root, "package.json"));
-    require2.resolve(EMBEDDING_RUNTIME_PACKAGE);
-    const packagePath = join11(root, "node_modules", ...EMBEDDING_RUNTIME_PACKAGE.split("/"), "package.json");
-    const version = JSON.parse(readFileSync11(packagePath, "utf8")).version;
+    const require3 = createRequire2(join15(root, "package.json"));
+    require3.resolve(EMBEDDING_RUNTIME_PACKAGE);
+    const packagePath = join15(root, "node_modules", ...EMBEDDING_RUNTIME_PACKAGE.split("/"), "package.json");
+    const version = JSON.parse(readFileSync14(packagePath, "utf8")).version;
     return { ok: true, installed: true, installAvailable: true, package: EMBEDDING_RUNTIME_PACKAGE, requiredVersion: EMBEDDING_RUNTIME_VERSION, packageVersion: version, location: root };
   } catch {
     return { ok: true, installed: false, installAvailable: true, package: EMBEDDING_RUNTIME_PACKAGE, requiredVersion: EMBEDDING_RUNTIME_VERSION, packageVersion: null, location: root };
@@ -2926,10 +3895,10 @@ function embeddingRuntimeStatus(options = {}) {
 function installEmbeddingRuntime(options = {}) {
   if (options.confirm !== true) throw new Error("Embedding runtime installation requires explicit confirmation.");
   const root = embeddingRuntimeRoot(options);
-  const lock = join11(root, ".installing");
-  if (existsSync12(lock)) throw new Error("Embedding runtime installation is already in progress.");
-  mkdirSync3(root, { recursive: true });
-  writeFileSync4(lock, `${process.pid}
+  const lock = join15(root, ".installing");
+  if (existsSync15(lock)) throw new Error("Embedding runtime installation is already in progress.");
+  mkdirSync4(root, { recursive: true });
+  writeFileSync5(lock, `${process.pid}
 `, { flag: "wx" });
   try {
     const spawn = options.spawnImpl ?? spawnSync2;
@@ -3029,13 +3998,13 @@ async function resolveEmbedder(root, options = {}) {
 }
 
 // packages/cli/src/query/store.mjs
-import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync12, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join12 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { existsSync as existsSync16, mkdirSync as mkdirSync5, readFileSync as readFileSync15, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join16 } from "node:path";
 var VECTOR_SCHEMA_VERSION = 2;
 var VECTOR_DIMENSIONS = 384;
-function profileFingerprint(identity) {
-  return createHash4("sha256").update(JSON.stringify(identity)).digest("hex");
+function profileFingerprint(identity2) {
+  return createHash6("sha256").update(JSON.stringify(identity2)).digest("hex");
 }
 function isValidNormalizedVectorValues(values, dimensions = VECTOR_DIMENSIONS) {
   if (!Number.isInteger(dimensions) || dimensions < 1 || !values || values.length % dimensions !== 0) return false;
@@ -3051,18 +4020,18 @@ function isValidNormalizedVectorValues(values, dimensions = VECTOR_DIMENSIONS) {
   return true;
 }
 function vectorCachePaths(root) {
-  const directory = join12(root, ".dotdotgod", "vectors");
-  return { directory, manifest: join12(directory, "manifest.json"), chunks: join12(directory, "chunks.jsonl"), embeddings: join12(directory, "embeddings.f32") };
+  const directory = join16(root, ".dotdotgod", "vectors");
+  return { directory, manifest: join16(directory, "manifest.json"), chunks: join16(directory, "chunks.jsonl"), embeddings: join16(directory, "embeddings.f32") };
 }
-function readVectorCache(root, identity = null) {
+function readVectorCache(root, identity2 = null) {
   const paths = vectorCachePaths(root);
-  if (!existsSync13(paths.manifest) || !existsSync13(paths.chunks) || !existsSync13(paths.embeddings)) return null;
+  if (!existsSync16(paths.manifest) || !existsSync16(paths.chunks) || !existsSync16(paths.embeddings)) return null;
   try {
-    const manifest = JSON.parse(readFileSync12(paths.manifest, "utf8"));
+    const manifest = JSON.parse(readFileSync15(paths.manifest, "utf8"));
     if (manifest.schemaVersion !== VECTOR_SCHEMA_VERSION || !Number.isInteger(manifest.dimensions) || manifest.dimensions < 1) return null;
-    if (identity && manifest.profileFingerprint !== profileFingerprint(identity)) return null;
-    const chunks = readFileSync12(paths.chunks, "utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line));
-    const buffer = readFileSync12(paths.embeddings);
+    if (identity2 && manifest.profileFingerprint !== profileFingerprint(identity2)) return null;
+    const chunks = readFileSync15(paths.chunks, "utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line));
+    const buffer = readFileSync15(paths.embeddings);
     if (buffer.byteLength !== chunks.length * manifest.dimensions * 4) return null;
     const vectors = new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4);
     if (!isValidNormalizedVectorValues(vectors, manifest.dimensions)) return null;
@@ -3073,14 +4042,14 @@ function readVectorCache(root, identity = null) {
 }
 function atomicWrite(path, data) {
   const temporary = `${path}.tmp-${process.pid}`;
-  writeFileSync5(temporary, data);
-  renameSync(temporary, path);
+  writeFileSync6(temporary, data);
+  renameSync2(temporary, path);
 }
 function writeVectorCache(root, chunks, vectors, metadata = {}) {
   const paths = vectorCachePaths(root);
   const dimensions = metadata.dimensions;
   if (!Number.isInteger(dimensions) || dimensions < 1) throw new Error("Vector dimensions must be a positive integer.");
-  mkdirSync4(paths.directory, { recursive: true });
+  mkdirSync5(paths.directory, { recursive: true });
   if (vectors.length !== chunks.length * dimensions) throw new Error("Vector count does not match chunk metadata.");
   if (!isValidNormalizedVectorValues(vectors, dimensions)) throw new Error("Vectors must contain finite normalized values.");
   const manifest = { schemaVersion: VECTOR_SCHEMA_VERSION, chunks: chunks.length, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), ...metadata };
@@ -3092,17 +4061,85 @@ function writeVectorCache(root, chunks, vectors, metadata = {}) {
   return manifest;
 }
 
+// packages/cli/src/query/hybrid.mjs
+var resultKey = (chunk) => chunk.kind === "symbol" ? chunk.id : chunk.path;
+var terms = (text) => [...new Set(text.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean))];
+function keywordCandidates(query, chunks) {
+  const words = terms(query);
+  if (!words.length) return [];
+  const literal = query.toLowerCase();
+  return chunks.map((chunk) => {
+    const names = `${chunk.qualifiedName ?? ""} ${chunk.heading ?? ""} ${chunk.path}`.toLowerCase();
+    const body = `${chunk.signature ?? ""} ${chunk.documentation ?? chunk.text}`.toLowerCase();
+    const haystack = new Set(terms(`${names} ${body}`));
+    const matched = words.filter((word) => haystack.has(word)).length;
+    const exact = chunk.qualifiedName?.toLowerCase() === literal || chunk.name?.toLowerCase() === literal;
+    return { ...chunk, exactNameMatch: Boolean(exact), keywordScore: exact ? 3 : matched / words.length + (names.includes(literal) ? 0.5 : body.includes(literal) ? 0.25 : 0) };
+  }).filter((chunk) => chunk.keywordScore > 0).sort((a, b) => b.keywordScore - a.keywordScore || a.id.localeCompare(b.id));
+}
+function fuseCandidates(keyword, vector, limit) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const [channel, rows] of [["keyword", keyword], ["vector", vector]]) {
+    const seenIds = /* @__PURE__ */ new Set();
+    let rank = 0;
+    rows.forEach((chunk) => {
+      if (seenIds.has(chunk.id)) return;
+      seenIds.add(chunk.id);
+      rank += 1;
+      const existing = candidates.get(chunk.id) ?? { ...chunk, score: 0, retrieval: [] };
+      existing.score += 1 / (60 + rank);
+      existing.retrieval.push(channel);
+      if (chunk.vectorScore !== void 0) existing.vectorScore = chunk.vectorScore;
+      if (chunk.keywordScore !== void 0) existing.keywordScore = chunk.keywordScore;
+      candidates.set(chunk.id, existing);
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return [...candidates.values()].sort((a, b) => Number(b.exactNameMatch ?? false) - Number(a.exactNameMatch ?? false) || b.score - a.score || a.id.localeCompare(b.id)).filter((chunk) => {
+    const key = resultKey(chunk);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }).slice(0, limit);
+}
+async function projectCorpus(root, scope) {
+  const config = readMemoryConfig(root);
+  const docs = scope === "code" ? [] : collectDocumentationChunks(root, config.load?.documentationSummary?.exclude, config.documentation?.root ?? "docs").map((chunk) => ({ ...chunk, kind: "document" }));
+  const outlines = scope === "docs" ? null : await buildOutlines(root);
+  return { chunks: [...docs, ...outlines ? outlineChunks(outlines) : []], outlines };
+}
+function assertCodeEmbeddingConsent(root, options, chunks) {
+  if (!chunks.some((chunk) => chunk.kind === "symbol")) return;
+  const profile = options.profile ?? resolveEmbeddingProfile(root).profile;
+  if (profile.provider !== "local" && options.allowCodeEmbedding !== true) throw new Error("Remote code-metadata embedding requires --allow-code-embedding; use --search keyword or --scope docs instead.");
+}
+function attachRelationships(results, outlines) {
+  if (!outlines) return results;
+  const graph = addOutlineGraph({ nodes: [], edges: [] }, outlines);
+  return results.map((result) => {
+    const relationships = graph.edges.filter((edge) => edge.source === result.id || edge.target === result.id || edge.source === `file:${result.path}` && edge.relation === "imports");
+    return { ...result, relationshipCount: relationships.length, relationships: relationships.slice(0, 10) };
+  });
+}
+
 // packages/cli/src/commands/query.mjs
 var DEFAULT_LIMIT = 30;
 var MAX_LIMIT = 100;
 var EMBED_BATCH_SIZE = 16;
 function parseQueryOptions(argv) {
-  const options = { root: ".", query: "", limit: DEFAULT_LIMIT, json: false };
+  const options = { root: ".", query: "", limit: DEFAULT_LIMIT, json: false, scope: "all", search: "hybrid", allowCodeEmbedding: false };
   let rootSet = false;
   const queryParts = [];
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
     if (arg === "--json") options.json = true;
+    else if (arg === "--scope") {
+      options.scope = argv[++i];
+      if (!["docs", "code", "all"].includes(options.scope)) usage("--scope must be docs, code or all.", "query");
+    } else if (arg === "--search") {
+      options.search = argv[++i];
+      if (!["hybrid", "keyword", "vector"].includes(options.search)) usage("--search must be hybrid, keyword or vector.", "query");
+    } else if (arg === "--allow-code-embedding") options.allowCodeEmbedding = true;
     else if (arg === "--limit") {
       const value = Number(argv[++i]);
       if (!Number.isInteger(value) || value < 1 || value > MAX_LIMIT) usage(`--limit must be an integer from 1 to ${MAX_LIMIT}.`, "query");
@@ -3141,20 +4178,12 @@ function rankVectorFiles(queryVector, index) {
   }
   return results;
 }
-function lexicalBoost(query, chunk) {
-  const terms = new Set(query.toLowerCase().split(/[^\p{L}\p{N}_.:/-]+/u).filter((term) => term.length > 1));
-  if (!terms.size) return 0;
-  const haystack = `${chunk.path} ${chunk.heading}`.toLowerCase();
-  let matches = 0;
-  for (const term of terms) if (haystack.includes(term)) matches += 1;
-  return Math.min(0.08, matches / terms.size * 0.08);
-}
 async function buildVectorIndex(root, embedOrOptions = {}) {
   const options = typeof embedOrOptions === "function" ? { embed: embedOrOptions } : embedOrOptions;
   const resolved = await resolveEmbedder(root, options);
   const config = readMemoryConfig(root);
   const exclude = config.load?.documentationSummary?.exclude ?? ["docs/plan", "docs/archive"];
-  const chunks = collectDocumentationChunks(root, exclude, config.documentation?.root ?? "docs");
+  const chunks = options.chunks ?? collectDocumentationChunks(root, exclude, config.documentation?.root ?? "docs");
   const cached = readVectorCache(root, resolved.identity);
   const cachedOffsets = new Map((cached?.chunks ?? []).map((chunk, index) => [chunk.fingerprint, index]));
   const rows = new Array(chunks.length);
@@ -3188,19 +4217,49 @@ async function buildVectorIndex(root, embedOrOptions = {}) {
   const manifest = writeVectorCache(root, storedChunks, vectors, { provider: resolved.profile.provider, model: resolved.profile.model, dimensions, profileFingerprint: profileFingerprint(resolved.identity), excluded: exclude, embedded: missing.length, reused });
   return { chunks: storedChunks, vectors, manifest, embedding: resolved };
 }
-async function queryDocumentation(root, query, options = {}) {
+async function queryProject(root, query, options = {}) {
+  const scope = options.scope ?? "all";
+  const search = options.search ?? "hybrid";
   const limit = options.limit ?? DEFAULT_LIMIT;
-  const index = await buildVectorIndex(root, options);
-  const [queryVector] = await index.embedding.embed([`query: ${query}`]);
-  const dimensions = index.manifest.dimensions;
-  assertVector(queryVector, dimensions, "Query vector");
-  const results = rankVectorFiles(queryVector, index).map((chunk) => ({ ...chunk, score: Number((chunk.vectorScore + lexicalBoost(query, chunk)).toFixed(6)), vectorScore: Number(chunk.vectorScore.toFixed(6)) })).sort((a, b) => b.score - a.score || a.path.localeCompare(b.path)).slice(0, limit);
-  return { ok: true, command: "query", root, query, provider: index.embedding.profile.provider, model: index.embedding.profile.model, embeddingSource: index.embedding.source, dimensions, limit, index: index.manifest, results };
+  const corpus = await projectCorpus(root, scope);
+  const keyword = search === "vector" ? [] : keywordCandidates(query, corpus.chunks);
+  let vector = [];
+  let index;
+  let vectorError;
+  if (search !== "keyword" && corpus.chunks.length) {
+    try {
+      assertCodeEmbeddingConsent(root, options, corpus.chunks);
+      index = await buildVectorIndex(root, { ...options, chunks: corpus.chunks });
+      const [queryVector] = await index.embedding.embed([`query: ${query}`]);
+      vector = index.chunks.map((chunk, position) => ({ ...chunk, vectorScore: cosineScore(queryVector, index.vectors, position * index.manifest.dimensions, index.manifest.dimensions) })).sort((a, b) => b.vectorScore - a.vectorScore || a.id.localeCompare(b.id));
+    } catch (error) {
+      if (search === "vector") throw error;
+      vectorError = error instanceof Error ? error.message : String(error);
+    }
+  }
+  const results = attachRelationships(fuseCandidates(keyword, vector, limit), corpus.outlines).map(({ passage, ...result }) => result);
+  return {
+    ok: true,
+    command: "query",
+    root,
+    query,
+    scope,
+    search,
+    limit,
+    provider: index?.embedding.profile.provider ?? null,
+    model: index?.embedding.profile.model ?? null,
+    embeddingSource: index?.embedding.source ?? "not-used",
+    dimensions: index?.manifest.dimensions ?? null,
+    index: index?.manifest ?? null,
+    outlines: corpus.outlines ? { refresh: corpus.outlines.refresh, indexedFiles: corpus.outlines.files.length, diagnostics: corpus.outlines.files.filter((file) => file.status !== "parsed").map(({ path, status }) => ({ path, status })) } : null,
+    warnings: [...vectorError ? [`Vector retrieval unavailable; keyword results only: ${vectorError}`] : [], ...corpus.outlines?.files.filter((file) => file.status !== "parsed").map((file) => `Outline ${file.status}: ${file.path}`) ?? []],
+    results
+  };
 }
 function formatQueryResult(payload) {
-  const lines = [`dotdotgod query: ${payload.query}`, `- embedding: ${payload.provider}/${payload.model} (${payload.embeddingSource})`, `- results: ${payload.results.length}`];
+  const lines = [`dotdotgod query: ${payload.query}`, `- embedding: ${payload.provider ? `${payload.provider}/${payload.model}` : "not used"} (${payload.embeddingSource})`, `- results: ${payload.results.length}`, ...payload.warnings ?? []];
   payload.results.forEach((result, index) => {
-    lines.push(`${index + 1}. ${result.path}${result.heading ? ` \u2014 ${result.heading}` : ""} (${result.score.toFixed(3)})`);
+    lines.push(`${index + 1}. ${result.path}${result.startLine ? `:${result.startLine}\u2013${result.endLine}` : ""}${result.heading ? ` \u2014 ${result.heading}` : ""} (${result.score.toFixed(3)})`);
     const excerpt = result.text.replace(/\s+/g, " ").trim().slice(0, 240);
     if (excerpt) lines.push(`   ${excerpt}${result.text.length > 240 ? "\u2026" : ""}`);
   });
@@ -3209,7 +4268,7 @@ function formatQueryResult(payload) {
 async function runQuery(argv) {
   const options = parseQueryOptions(argv);
   try {
-    const payload = await queryDocumentation(options.root, options.query, options);
+    const payload = await queryProject(options.root, options.query, options);
     console.log(options.json ? JSON.stringify(payload, null, 2) : formatQueryResult(payload));
   } catch (error) {
     const message = `dotdotgod query failed: ${error instanceof Error ? error.message : String(error)}`;
@@ -3255,8 +4314,8 @@ function runEmbedding(argv, options = {}) {
 import { resolve as resolve13 } from "node:path";
 
 // packages/cli/src/memory/documentation-map.mjs
-import { existsSync as existsSync14, readdirSync as readdirSync4, statSync as statSync7 } from "node:fs";
-import { join as join13, resolve as resolve12 } from "node:path";
+import { existsSync as existsSync17, readdirSync as readdirSync4, statSync as statSync7 } from "node:fs";
+import { join as join17, resolve as resolve12 } from "node:path";
 var SKIPPED_DIRECTORIES2 = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "coverage", ".git", ".dotdotgod"]);
 function node() {
   return { directories: /* @__PURE__ */ new Map(), files: [] };
@@ -3319,7 +4378,7 @@ function discoverMarkdown(root, documentationRoot, exclude) {
   const walk = (relativeDirectory) => {
     let entries;
     try {
-      entries = readdirSync4(join13(root, relativeDirectory), { withFileTypes: true, encoding: "utf8" });
+      entries = readdirSync4(join17(root, relativeDirectory), { withFileTypes: true, encoding: "utf8" });
     } catch {
       return;
     }
@@ -3337,7 +4396,7 @@ function discoverMarkdown(root, documentationRoot, exclude) {
 }
 function buildDocumentationMap(projectRoot = ".", { depth = 5 } = {}) {
   const root = resolve12(projectRoot);
-  if (!existsSync14(root)) return { ok: false, error: { code: "ROOT_NOT_FOUND", message: `Project root not found: ${root}` } };
+  if (!existsSync17(root)) return { ok: false, error: { code: "ROOT_NOT_FOUND", message: `Project root not found: ${root}` } };
   try {
     if (!statSync7(root).isDirectory()) return { ok: false, error: { code: "ROOT_NOT_FOUND", message: `Project root not found: ${root}` } };
   } catch {
@@ -4768,8 +5827,8 @@ function compareImpactItems(seeds) {
 }
 
 // packages/cli/src/impact/references.mjs
-import { readFileSync as readFileSync13, statSync as statSync8 } from "node:fs";
-import { extname as extname5, resolve as resolve14 } from "node:path";
+import { readFileSync as readFileSync16, statSync as statSync8 } from "node:fs";
+import { extname as extname7, resolve as resolve14 } from "node:path";
 var WARNING_LIMIT = 20;
 var edgeKey = (source, target, relation) => `${source}\0${target}\0${relation}`;
 function prepareImpactReferences(index, root, changedPaths) {
@@ -4784,7 +5843,7 @@ function prepareImpactReferences(index, root, changedPaths) {
       const absolute = resolve14(root, path);
       const stat = statSync8(absolute);
       result = { status: "exists" };
-      if (stat.isFile() && extname5(absolute) === ".md") result.anchors = extractAnchors(readFileSync13(absolute, "utf8"));
+      if (stat.isFile() && extname7(absolute) === ".md") result.anchors = extractAnchors(readFileSync16(absolute, "utf8"));
     } catch (error) {
       result = { status: ["ENOENT", "ENOTDIR"].includes(error.code) ? "missing" : "unavailable" };
     }
@@ -4846,8 +5905,8 @@ function prepareImpactReferences(index, root, changedPaths) {
 }
 
 // packages/cli/src/impact/vector-profile.mjs
-import { lstatSync, readFileSync as readFileSync14, realpathSync } from "node:fs";
-import { extname as extname6, relative as relative5, resolve as resolve15, sep } from "node:path";
+import { lstatSync as lstatSync3, readFileSync as readFileSync17, realpathSync as realpathSync2 } from "node:fs";
+import { extname as extname8, relative as relative6, resolve as resolve15, sep } from "node:path";
 var MAX_VECTOR_PROFILE_FILE_BYTES = 64 * 1024;
 var MAX_VECTOR_PROFILE_CHARS = 4e3;
 var MAX_VECTOR_PROFILE_METADATA_ITEMS = 20;
@@ -4869,13 +5928,13 @@ function canonicalizeChangedPath(root, path) {
   const absolute = resolve15(rootAbsolute, normalized);
   if (!insideRoot(rootAbsolute, absolute)) return normalized;
   try {
-    const canonicalRoot = realpathSync(rootAbsolute);
-    const canonicalAbsolute = realpathSync(absolute);
+    const canonicalRoot = realpathSync2(rootAbsolute);
+    const canonicalAbsolute = realpathSync2(absolute);
     if (!insideRoot(canonicalRoot, canonicalAbsolute)) return normalized;
-    const canonical = relative5(canonicalRoot, canonicalAbsolute).replaceAll("\\", "/");
+    const canonical = relative6(canonicalRoot, canonicalAbsolute).replaceAll("\\", "/");
     return canonical || normalized;
   } catch {
-    return relative5(rootAbsolute, absolute).replaceAll("\\", "/") || normalized;
+    return relative6(rootAbsolute, absolute).replaceAll("\\", "/") || normalized;
   }
 }
 function unsafeProfilePath(path) {
@@ -4895,17 +5954,17 @@ function graphMetadata(graph, seedId) {
   return values;
 }
 function safeTextPrefix(root, path) {
-  if (unsafeProfilePath(path) || !TEXT_EXTENSIONS.has(extname6(path).toLowerCase())) return "";
+  if (unsafeProfilePath(path) || !TEXT_EXTENSIONS.has(extname8(path).toLowerCase())) return "";
   try {
     const absolute = resolve15(root, path);
     if (!insideRoot(root, absolute)) return "";
-    const canonicalAbsolute = realpathSync(absolute);
-    if (!insideRoot(realpathSync(root), canonicalAbsolute)) return "";
-    const canonicalPath = relative5(realpathSync(root), canonicalAbsolute).replaceAll("\\", "/");
-    if (canonicalPath !== path || unsafeProfilePath(canonicalPath) || !TEXT_EXTENSIONS.has(extname6(canonicalPath).toLowerCase())) return "";
-    const stats = lstatSync(canonicalAbsolute);
+    const canonicalAbsolute = realpathSync2(absolute);
+    if (!insideRoot(realpathSync2(root), canonicalAbsolute)) return "";
+    const canonicalPath = relative6(realpathSync2(root), canonicalAbsolute).replaceAll("\\", "/");
+    if (canonicalPath !== path || unsafeProfilePath(canonicalPath) || !TEXT_EXTENSIONS.has(extname8(canonicalPath).toLowerCase())) return "";
+    const stats = lstatSync3(canonicalAbsolute);
     if (!stats.isFile() || stats.isSymbolicLink() || stats.size > MAX_VECTOR_PROFILE_FILE_BYTES) return "";
-    const buffer = readFileSync14(canonicalAbsolute);
+    const buffer = readFileSync17(canonicalAbsolute);
     if (buffer.includes(0)) return "";
     const text = new TextDecoder("utf-8", { fatal: true }).decode(buffer);
     return text.slice(0, MAX_VECTOR_PROFILE_CHARS);
@@ -5125,7 +6184,7 @@ function buildCompactImpactReport(impact, limits = {}) {
 }
 
 // packages/cli/src/reference/extract.mjs
-import { basename as basename8, dirname as dirname7, extname as extname7 } from "node:path";
+import { basename as basename8, dirname as dirname11, extname as extname9 } from "node:path";
 var DEFAULT_REFERENCE_LIMIT = 5;
 function extractBracketReferences(prompt = "") {
   const refs = [];
@@ -5170,13 +6229,13 @@ function isArchiveBodyPath(path = "", memoryConfig) {
 function aliasEntriesForPath(path = "") {
   const entries = [];
   const base = basename8(path);
-  const ext = extname7(base);
+  const ext = extname9(base);
   const stem = ext ? base.slice(0, -ext.length) : base;
   const withoutMd = path.replace(/\.md$/i, "");
   const parts = withoutMd.split("/").filter(Boolean);
   for (let i = 0; i < parts.length; i += 1) entries.push({ alias: parts.slice(i).join("/"), kind: "path-suffix" });
   if (base === "README.md") {
-    const dir = dirname7(path).replace(/\\/g, "/");
+    const dir = dirname11(path).replace(/\\/g, "/");
     entries.push({ alias: basename8(dir), kind: "path" });
   }
   for (const alias of [path, withoutMd, base, stem]) entries.push({ alias, kind: "path" });
@@ -5187,7 +6246,7 @@ function referenceCandidateAliases(node2) {
   const entries = [];
   if (node2.type === "file" && path) entries.push(...aliasEntriesForPath(path));
   if (node2.type === "heading") {
-    const fileStem = path ? basename8(path, extname7(path)) : "";
+    const fileStem = path ? basename8(path, extname9(path)) : "";
     const anchor = typeof node2.id === "string" && node2.id.includes("#") ? node2.id.split("#").pop() : "";
     for (const alias of [node2.title, anchor, fileStem && node2.title ? `${fileStem}#${node2.title}` : "", fileStem && anchor ? `${fileStem}#${anchor}` : "", path && node2.title ? `${path}#${node2.title}` : "", path && anchor ? `${path}#${anchor}` : ""]) entries.push({ alias, kind: "heading" });
   }
@@ -5355,15 +6414,15 @@ function runExpand(argv) {
 }
 
 // packages/cli/src/commands/traceability.mjs
-import { existsSync as existsSync15, readFileSync as readFileSync15, readdirSync as readdirSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join14, resolve as resolve17 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync18, readdirSync as readdirSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join18, resolve as resolve17 } from "node:path";
 function collectDocsMarkdownFiles(root) {
-  const docs = join14(root, "docs");
+  const docs = join18(root, "docs");
   const files = [];
   const walk = (dir) => {
-    if (!existsSync15(dir)) return;
+    if (!existsSync18(dir)) return;
     for (const entry of readdirSync5(dir, { withFileTypes: true })) {
-      const path = join14(dir, entry.name);
+      const path = join18(dir, entry.name);
       if (entry.isDirectory()) walk(path);
       else if (entry.isFile() && entry.name.endsWith(".md")) files.push(path);
     }
@@ -5399,7 +6458,7 @@ function runTraceability(argv) {
   const errors = [...config.errors ?? []];
   for (const file of files) {
     if (options.write && errors.length > 0) break;
-    const content = readFileSync15(file, "utf8");
+    const content = readFileSync18(file, "utf8");
     for (const error of validateTraceabilityLinksRegion(content, options.root, file)) errors.push(error);
     const blocks = extractDotdotgodTraceabilityBlocks(content).filter((block) => !block.error);
     if (blocks.length === 0) continue;
@@ -5408,7 +6467,7 @@ function runTraceability(argv) {
       for (const error of result.errors ?? []) errors.push(error);
       continue;
     }
-    if (options.write && result.changed) writeFileSync6(file, result.content);
+    if (options.write && result.changed) writeFileSync7(file, result.content);
     if (result.changed) results.push({ file: rel(options.root, file), changed: true });
   }
   const ok = errors.length === 0 && (!options.check || results.length === 0);
@@ -5429,9 +6488,9 @@ function runTraceability(argv) {
 
 // packages/cli/src/graph-view/server.mjs
 import { createServer } from "node:http";
-import { readFileSync as readFileSync16 } from "node:fs";
-import { dirname as dirname8, extname as extname8, join as join15 } from "node:path";
-import { fileURLToPath } from "node:url";
+import { readFileSync as readFileSync19 } from "node:fs";
+import { dirname as dirname12, extname as extname10, join as join19 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/cli/src/graph-view/payload.mjs
 function edgeKey2(edge) {
@@ -5542,7 +6601,7 @@ function buildImpactGraphPayload(index, impact) {
 }
 
 // packages/cli/src/graph-view/server.mjs
-var ASSET_ROOT = join15(dirname8(fileURLToPath(import.meta.url)), "assets");
+var ASSET_ROOT = join19(dirname12(fileURLToPath2(import.meta.url)), "assets");
 var CONTENT_TYPES = { ".css": "text/css; charset=utf-8", ".html": "text/html; charset=utf-8", ".js": "text/javascript; charset=utf-8", ".map": "application/json; charset=utf-8" };
 var VENDOR_FILES = {
   "/vendor/sigma.js": new URL("../../node_modules/sigma/dist/sigma.min.js", import.meta.url),
@@ -5555,8 +6614,8 @@ function json(response, status, value) {
 }
 function asset(response, file) {
   try {
-    const body = readFileSync16(file);
-    response.writeHead(200, { "content-type": CONTENT_TYPES[extname8(file)] ?? "application/octet-stream", "cache-control": "no-store" });
+    const body = readFileSync19(file);
+    response.writeHead(200, { "content-type": CONTENT_TYPES[extname10(file)] ?? "application/octet-stream", "cache-control": "no-store" });
     response.end(body);
   } catch {
     response.writeHead(404);
@@ -5591,13 +6650,13 @@ async function startImpactGraphServer({ root, changed, host = "127.0.0.1", port
         return json(response, 500, { ok: false, error: { code: "GRAPH_SERVE_FAILED", message: error instanceof Error ? error.message : String(error) } });
       }
     }
-    if (VENDOR_FILES[url.pathname]) return asset(response, fileURLToPath(VENDOR_FILES[url.pathname]));
-    const relative6 = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
-    if (!["index.html", "app.css", "app.js"].includes(relative6)) {
+    if (VENDOR_FILES[url.pathname]) return asset(response, fileURLToPath2(VENDOR_FILES[url.pathname]));
+    const relative7 = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
+    if (!["index.html", "app.css", "app.js"].includes(relative7)) {
       response.writeHead(404);
       return response.end("Not found");
     }
-    return asset(response, join15(ASSET_ROOT, relative6));
+    return asset(response, join19(ASSET_ROOT, relative7));
   });
   await new Promise((resolve18, reject) => {
     server.once("error", reject);
@@ -5825,7 +6884,7 @@ async function runCli(argv = process.argv.slice(2)) {
   if (hasHelpToken(args)) usage("", helpCommandFromArgs([command, ...args]));
   if (command === "validate") runValidate(args);
   else if (command === "init") runInit(args, usage);
-  else if (command === "index") runIndex(args);
+  else if (command === "index") await runIndex(args);
   else if (command === "config") runConfig(args);
   else if (command === "status") runStatus(args);
   else if (command === "query") await runQuery(args);