prehello 0.1.0 → 1.0.0

package/dist/adapters/cursor.js

@@ -3,8 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CURSOR_LISTING_NOTE = exports.CURSOR_DESC_CHARS = void 0;
 exports.detectCursor = detectCursor;
 exports.discoverCursor = discoverCursor;
+exports.cursorSkillLine = cursorSkillLine;
 const node_path_1 = __importDefault(require("node:path"));
 const spec_1 = require("../spec");
 const fs_safe_1 = require("../fs-safe");
@@ -180,14 +182,19 @@ function discoverCursor(ctx) {
     }
     // Skills. Listing (name+description) is assumed to load up front, bodies on demand; listing format/cost is UNVERIFIED for Cursor.
     const seenSkill = new Set();
-    const cursorSkillNotes = (extra) => ["Cursor lists each skill's name + description (exact injection format and token cost unverified; counted as name: description)", ...(extra ? [extra] : [])];
+    const cursorSkillNotes = (extra) => [exports.CURSOR_LISTING_NOTE, ...(extra ? [extra] : [])];
     const emitSkills = (recs, dir, scope, tag, confidence, note, forceConditional = false) => {
         const fresh = recs.filter((r) => !seenSkill.has(r.realPath));
         for (const r of fresh)
             seenSkill.add(r.realPath);
         const unscoped = fresh.filter((r) => r.scopedTo.length === 0);
         const scoped = fresh.filter((r) => r.scopedTo.length > 0);
-        const spec = { agent: AGENT, dir, scope, confidence, evidence: ev(SKILLS_DOC), lineFor: (r) => (r.disableModelInvocation ? null : `${r.name}: ${r.desc}`) };
+        const spec = {
+            agent: AGENT, dir, scope, confidence, evidence: ev(SKILLS_DOC),
+            lineFor: (r) => (r.disableModelInvocation ? null : cursorSkillLine(dir, r, "short")),
+            lowLineFor: (r) => cursorSkillLine(dir, r, "none"),
+            highLineFor: (r) => cursorSkillLine(dir, r, "full"),
+        };
         if (unscoped.length)
             items.push(...(0, skills_1.skillItems)(ctx, { ...spec, tag, recs: unscoped, listingMode: forceConditional ? "conditional" : "always", notes: cursorSkillNotes(note) }));
         if (scoped.length)
@@ -255,3 +262,14 @@ function discoverCursor(ctx) {
     }
     return { items, unmeasuredBanner: banner };
 }
+/** Observed Cursor listing (forum.cursor.com/t/163761, staff-confirmed 2026-06-22): description cut to about 80 characters. */
+exports.CURSOR_DESC_CHARS = 80;
+const CURSOR_PATH_STANDIN = "/Users/you/.cursor/skills";
+exports.CURSOR_LISTING_NOTE = "Cursor lists each skill as <agent_skill fullPath=...> with its description cut to ~80 characters, and drops descriptions when the catalog is large (observed, confirmed by Cursor staff 2026-06; budget undocumented). Estimate = 80-character form; low = path only; high = full description.";
+/** One `<agent_skill>` entry. The absolute path is approximated by a fixed stand-in + the path below the skills root (deterministic, never output). */
+function cursorSkillLine(root, r, desc) {
+    const rel = node_path_1.default.relative(root, r.file).split(node_path_1.default.sep).join("/");
+    const d = r.desc.trim();
+    const text = desc === "none" ? "" : desc === "full" || d.length <= exports.CURSOR_DESC_CHARS ? d : `${d.slice(0, exports.CURSOR_DESC_CHARS)}...`;
+    return `<agent_skill fullPath="${CURSOR_PATH_STANDIN}/${rel}">${text}</agent_skill>`;
+}

package/dist/adapters/gemini-cli.js

@@ -0,0 +1,214 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectGemini = detectGemini;
+exports.discoverGemini = discoverGemini;
+const node_path_1 = __importDefault(require("node:path"));
+const context_1 = require("../context");
+const spec_1 = require("../spec");
+const fs_safe_1 = require("../fs-safe");
+const common_1 = require("./common");
+const configs_1 = require("../mcp/configs");
+const skills_1 = require("./skills");
+const AGENT = "gemini-cli";
+const ev = (doc) => (0, spec_1.evidenceFor)(AGENT, doc);
+function geminiHome(ctx) {
+    return node_path_1.default.join(ctx.home, ".gemini");
+}
+function detectGemini(ctx) {
+    const by = [];
+    if ((0, fs_safe_1.isDir)(geminiHome(ctx)))
+        by.push("config dir");
+    if ((0, fs_safe_1.onPath)("gemini", ctx.opts.env.PATH ?? ctx.opts.env.Path, { platform: ctx.opts.platform, pathExt: ctx.opts.env.PATHEXT }))
+        by.push("binary on PATH");
+    const repo = [];
+    for (const rel of ["GEMINI.md", ".gemini"]) {
+        const p = node_path_1.default.join(ctx.cwd, rel);
+        if ((0, fs_safe_1.isFile)(p) || (0, fs_safe_1.isDir)(p))
+            repo.push(p);
+    }
+    return { detectedBy: by, repoFiles: repo };
+}
+const isObj = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
+/** settings.json may carry // comments in the wild; only strict JSON is parsed here (a failure is a warning, never a guess). */
+function readSettings(ctx, file, jail) {
+    if (!(0, fs_safe_1.isFile)(file))
+        return undefined;
+    const r = ctx.read(file, jail ? { jail } : {});
+    if (!r.ok)
+        return undefined;
+    try {
+        const j = JSON.parse(r.text);
+        return isObj(j) ? j : undefined;
+    }
+    catch {
+        ctx.warn(`${ctx.display(file)}: could not parse as JSON, skipped`);
+        return undefined;
+    }
+}
+function names(v) {
+    const list = typeof v === "string" ? [v] : Array.isArray(v) ? v : undefined;
+    if (!list)
+        return undefined;
+    const ok = list.filter((x) => typeof x === "string" && x.length > 0 && !/[\\/]/.test(x) && x !== "." && x !== "..");
+    return ok.length ? [...new Set(ok)] : undefined;
+}
+function discoverGemini(ctx) {
+    const caps = (0, spec_1.loadSpec)(AGENT).caps;
+    const items = [];
+    const banner = ["built-in system prompt and tools", "the directory tree Gemini CLI adds to the first request (context.includeDirectoryTree)", "saved memories and auto memory"];
+    const home = geminiHome(ctx);
+    const userSettingsFile = node_path_1.default.join(home, "settings.json");
+    const wsSettingsFile = node_path_1.default.join(ctx.cwd, ".gemini", "settings.json");
+    const user = readSettings(ctx, userSettingsFile) ?? {};
+    const ws = ctx.cwd === ctx.home ? {} : (readSettings(ctx, wsSettingsFile, ctx.jailFor(ctx.cwd)) ?? {});
+    const ctxOf = (s) => (isObj(s.context) ? s.context : {});
+    // Workspace settings override user settings (documented).
+    const pick = (k) => (ctxOf(ws)[k] !== undefined ? ctxOf(ws)[k] : ctxOf(user)[k]);
+    const fileNames = names(pick("fileName")) ?? names(ws.contextFileName) ?? names(user.contextFileName) ?? ["GEMINI.md"];
+    const markersRaw = pick("memoryBoundaryMarkers");
+    const markers = Array.isArray(markersRaw) ? markersRaw.filter((x) => typeof x === "string" && x.length > 0) : [".git"];
+    const customNames = !(fileNames.length === 1 && fileNames[0] === "GEMINI.md");
+    const nameNote = customNames ? [`context.fileName: ${fileNames.join(", ")}`] : [];
+    const importOpts = { imports: true, importMaxDepth: caps.importMaxDepth, stripComments: false };
+    // 1. Global context files
+    for (const n of fileNames) {
+        const f = node_path_1.default.join(home, n);
+        const it = (0, common_1.loadInstruction)(ctx, f, { agent: AGENT, scope: "user", loadMode: "always", label: `~/.gemini/${n}`, cardLabel: `global ${n}`, ...importOpts, confidence: "documented", evidence: ev("geminiMd"), notes: nameNote });
+        if (it)
+            items.push(it);
+    }
+    // 2. cwd and parents, up to the first directory holding a boundary marker (default .git), never the home folder itself
+    const up = [];
+    for (let d = ctx.cwd;;) {
+        if (d === ctx.home)
+            break;
+        up.push(d);
+        if (!markers.length)
+            break; // an empty list disables parent traversal (documented)
+        if (markers.some((m) => (0, fs_safe_1.isFile)(node_path_1.default.join(d, m)) || (0, fs_safe_1.isDir)(node_path_1.default.join(d, m))))
+            break;
+        if (ctx.opts.ceiling && d === ctx.opts.ceiling)
+            break;
+        const p = node_path_1.default.dirname(d);
+        if (p === d)
+            break;
+        d = p;
+    }
+    // Files above the boundary are not part of this project's context: say so instead of dropping them silently.
+    const top = up[up.length - 1];
+    const exists = (p) => (0, fs_safe_1.isFile)(p) || (0, fs_safe_1.isDir)(p);
+    if (top && markers.some((m) => exists(node_path_1.default.join(top, m)))) {
+        for (let d = top;;) {
+            if (ctx.opts.ceiling && d === ctx.opts.ceiling)
+                break;
+            const p = node_path_1.default.dirname(d);
+            if (p === d || p === ctx.home)
+                break;
+            d = p;
+            for (const n of fileNames)
+                if ((0, fs_safe_1.isFile)(node_path_1.default.join(d, n)))
+                    ctx.exclude(AGENT, node_path_1.default.join(d, n), `above the project root (${markers.join(", ")} boundary): Gemini CLI stops there`);
+        }
+    }
+    for (const dir of up.reverse()) {
+        for (const n of fileNames) {
+            const f = node_path_1.default.join(dir, n);
+            if (!(0, fs_safe_1.isFile)(f))
+                continue;
+            const it = (0, common_1.loadInstruction)(ctx, f, {
+                agent: AGENT, scope: dir === ctx.cwd ? "project" : "ancestor", loadMode: "always", label: ctx.display(f), cardLabel: n, jail: ctx.jailFor(dir),
+                ...importOpts, confidence: "documented", evidence: ev("geminiMd"), notes: nameNote,
+            });
+            if (it)
+                items.push(it);
+        }
+    }
+    // 3. Below cwd: just-in-time (loaded when a tool touches that directory). The project walk knows a fixed set of names.
+    const walkable = fileNames.filter((n) => context_1.WALK_CANDIDATES.includes(n));
+    let nNested = 0;
+    for (const hit of walkable.length ? ctx.walk().hits : []) {
+        if (hit.dir === ctx.cwd || !(0, fs_safe_1.isInside)(hit.dir, ctx.cwd))
+            continue;
+        for (const n of walkable) {
+            if (!hit.names.includes(n))
+                continue;
+            if (++nNested > caps.discoveryMaxDirs)
+                break;
+            const f = node_path_1.default.join(hit.dir, n);
+            const it = (0, common_1.loadInstruction)(ctx, f, {
+                agent: AGENT, scope: "nested", loadMode: "conditional", label: ctx.display(f), cardLabel: `nested ${n}`, jail: ctx.jailFor(hit.dir), ...importOpts,
+                confidence: "documented", evidence: ev("geminiMd"),
+                notes: ["just-in-time: loaded when a tool accesses that directory (docs/cli/gemini-md.md); older docs describe an eager scan of up to 200 subdirectories, which would make it always-on"],
+            });
+            if (it)
+                items.push(it);
+        }
+    }
+    const unwalked = fileNames.filter((n) => !walkable.includes(n));
+    if (unwalked.length)
+        banner.push(`context files named ${unwalked.join(", ")} below the working directory (not walked)`);
+    // 4. Extensions (~/.gemini/extensions/<name>/gemini-extension.json): context file + MCP servers
+    const extServers = [];
+    const extRoot = node_path_1.default.join(home, "extensions");
+    const exts = (0, fs_safe_1.listDir)(extRoot).filter((e) => e.isDirectory() && !e.name.startsWith("."));
+    for (const e of exts) {
+        const dir = node_path_1.default.join(extRoot, e.name);
+        const manifestFile = node_path_1.default.join(dir, "gemini-extension.json");
+        const m = readSettings(ctx, manifestFile, dir);
+        if (!m)
+            continue;
+        const note = "installed extension; per-workspace enable/disable state is not read (assumed enabled)";
+        const ctxNames = names(m.contextFileName) ?? ((0, fs_safe_1.isFile)(node_path_1.default.join(dir, "GEMINI.md")) ? ["GEMINI.md"] : []);
+        for (const n of ctxNames) {
+            const f = node_path_1.default.join(dir, n);
+            const it = (0, common_1.loadInstruction)(ctx, f, { agent: AGENT, scope: "plugin", loadMode: "always", label: `extension ${e.name}: ${n}`, cardLabel: "extension context", jail: dir, ...importOpts, confidence: "documented", evidence: ev("extensions"), notes: [note] });
+            if (it)
+                items.push(it);
+        }
+        for (const def of (0, configs_1.parseMcpMap)(m.mcpServers, (w) => ctx.warn(w)))
+            extServers.push({ file: manifestFile, def });
+    }
+    // 5. MCP: workspace settings override user settings; settings override extensions on a name clash (documented)
+    const seen = new Set();
+    const add = (file, scope, def, doc, extra) => {
+        if (def.disabled || seen.has(def.name))
+            return;
+        seen.add(def.name);
+        items.push(...(0, common_1.mcpItems)(ctx, { agent: AGENT, def, source: file, scope, mode: "full", evidence: ev(doc), notes: ["Gemini CLI connects to each server and registers all discovered tools; schemas modelled as loaded up front (assumed)", ...extra], index: items.length }));
+    };
+    for (const def of (0, configs_1.parseMcpMap)(ws.mcpServers, (w) => ctx.warn(w)))
+        add(wsSettingsFile, "project", def, "mcp", ["workspace settings (.gemini/settings.json)"]);
+    for (const def of (0, configs_1.parseMcpMap)(user.mcpServers, (w) => ctx.warn(w)))
+        add(userSettingsFile, "user", def, "mcp", []);
+    for (const x of extServers)
+        add(x.file, "plugin", x.def, "extensions", ["from an extension"]);
+    // 6. Skills: name + description listed up front, body on activation (documented). .agents/skills wins over .gemini/skills in a tier.
+    const seenSkill = new Set();
+    const line = (r) => `- ${r.name}: ${r.desc}`;
+    const emit = (dir, scope, tag, jail) => {
+        const recs = (0, skills_1.discoverSkills)(ctx, dir, jail ? { jail } : {}).filter((r) => {
+            if (seenSkill.has(r.name)) {
+                ctx.exclude(AGENT, r.file, "a skill with the same name in a higher-precedence location wins");
+                return false;
+            }
+            seenSkill.add(r.name);
+            return true;
+        });
+        if (!recs.length)
+            return;
+        items.push(...(0, skills_1.skillItems)(ctx, { agent: AGENT, dir, scope, tag, recs, lineFor: line, listingMode: "always", confidence: "documented", evidence: ev("skills"), notes: ["name + description are injected at session start (documented); exact wording of the listing is assumed"] }));
+    };
+    if (ctx.cwd !== ctx.home) {
+        emit(node_path_1.default.join(ctx.cwd, ".agents", "skills"), "project", "workspace", ctx.jailFor(ctx.cwd));
+        emit(node_path_1.default.join(ctx.cwd, ".gemini", "skills"), "project", "workspace .gemini", ctx.jailFor(ctx.cwd));
+    }
+    emit(node_path_1.default.join(ctx.home, ".agents", "skills"), "user", "user");
+    emit(node_path_1.default.join(home, "skills"), "user", "user .gemini");
+    if (exts.some((e) => (0, fs_safe_1.isDir)(node_path_1.default.join(extRoot, e.name, "skills"))))
+        banner.push("skills bundled in extensions");
+    banner.push("built-in skills");
+    return { items, unmeasuredBanner: banner };
+}

package/dist/adapters/github-copilot.js

@@ -0,0 +1,249 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectCopilot = detectCopilot;
+exports.discoverCopilot = discoverCopilot;
+const node_path_1 = __importDefault(require("node:path"));
+const spec_1 = require("../spec");
+const fs_safe_1 = require("../fs-safe");
+const frontmatter_1 = require("../text/frontmatter");
+const common_1 = require("./common");
+const configs_1 = require("../mcp/configs");
+const AGENT = "github-copilot";
+const ev = (doc) => (0, spec_1.evidenceFor)(AGENT, doc);
+function copilotHome(ctx) {
+    return ctx.opts.env.COPILOT_HOME || node_path_1.default.join(ctx.home, ".copilot");
+}
+/** VS Code's user profile folder (where the user-level mcp.json lives). */
+function vscodeUserDir(ctx) {
+    const plat = ctx.opts.platform ?? process.platform;
+    if (plat === "darwin")
+        return node_path_1.default.join(ctx.home, "Library", "Application Support", "Code", "User");
+    if (plat === "win32")
+        return node_path_1.default.join(ctx.opts.env.APPDATA || node_path_1.default.join(ctx.home, "AppData", "Roaming"), "Code", "User");
+    return node_path_1.default.join(ctx.opts.env.XDG_CONFIG_HOME || node_path_1.default.join(ctx.home, ".config"), "Code", "User");
+}
+function hasCopilotExtension(ctx) {
+    return (0, fs_safe_1.listDir)(node_path_1.default.join(ctx.home, ".vscode", "extensions")).some((e) => e.isDirectory() && /^github\.copilot(-chat)?-\d/i.test(e.name));
+}
+function detectCopilot(ctx) {
+    const by = [];
+    if ((0, fs_safe_1.isDir)(copilotHome(ctx)))
+        by.push("config dir");
+    if ((0, fs_safe_1.onPath)("copilot", ctx.opts.env.PATH ?? ctx.opts.env.Path, { platform: ctx.opts.platform, pathExt: ctx.opts.env.PATHEXT }))
+        by.push("binary on PATH");
+    if (hasCopilotExtension(ctx))
+        by.push("VS Code Copilot extension");
+    const repo = [];
+    const root = ctx.gitRoot ?? ctx.cwd;
+    for (const rel of [".github/copilot-instructions.md", ".github/instructions", ".github/prompts", ".vscode/mcp.json", ".github/mcp.json"]) {
+        const p = node_path_1.default.join(root, ...rel.split("/"));
+        if ((0, fs_safe_1.isFile)(p) || (0, fs_safe_1.isDir)(p))
+            repo.push(p);
+    }
+    return { detectedBy: by, repoFiles: repo };
+}
+const ALWAYS_NAMES = [
+    { rel: ".github/copilot-instructions.md", imports: true, card: "copilot-instructions.md" },
+    { rel: "AGENTS.md", imports: true, card: "AGENTS.md" },
+    { rel: "CLAUDE.md", imports: true, card: "CLAUDE.md" },
+    { rel: ".claude/CLAUDE.md", imports: true, card: "CLAUDE.md" },
+    { rel: "GEMINI.md", imports: false, card: "GEMINI.md" },
+];
+function discoverCopilot(ctx) {
+    const items = [];
+    const home = copilotHome(ctx);
+    const root = ctx.gitRoot ?? ctx.cwd;
+    const seenText = new Map(); // trimmed content -> first path (Copilot CLI removes identical copies)
+    /** true (and recorded as excluded) when the file's content was already counted. Checked before loading so a duplicate is not analysed twice. */
+    const isDup = (f, jail) => {
+        const r = ctx.read(f, jail ? { jail, quiet: true } : { quiet: true });
+        if (!r.ok)
+            return false;
+        const k = r.text.replace(/\r\n?/g, "\n").trim();
+        if (!k)
+            return false;
+        const first = seenText.get(k);
+        if (first !== undefined) {
+            ctx.exclude(AGENT, f, `identical to ${ctx.display(first)} (Copilot CLI removes duplicate copies)`);
+            return true;
+        }
+        seenText.set(k, f);
+        return false;
+    };
+    // User-level always-on instructions
+    const userInstr = node_path_1.default.join(home, "copilot-instructions.md");
+    const ui = isDup(userInstr) ? null : (0, common_1.loadInstruction)(ctx, userInstr, {
+        agent: AGENT, scope: "user", loadMode: "always", label: "~/.copilot/copilot-instructions.md", cardLabel: "user copilot-instructions.md",
+        stripComments: false, imports: true, importRoots: [home], importRelativeOnly: true, confidence: "documented", evidence: ev("cliInstructions"),
+    });
+    const uiKept = ui;
+    if (uiKept)
+        items.push(uiKept);
+    // Repository chain: repo root -> cwd (the "standard locations"; VS Code itself reads the root files)
+    const chain = ctx.ancestorDirs().filter((d) => (0, fs_safe_1.isInside)(d, root));
+    for (const dir of chain) {
+        const jail = ctx.jailFor(dir);
+        for (const n of ALWAYS_NAMES) {
+            const f = node_path_1.default.join(dir, ...n.rel.split("/"));
+            if (!(0, fs_safe_1.isFile)(f))
+                continue;
+            const cliOnly = n.rel.includes("CLAUDE") || n.rel === "GEMINI.md";
+            const notes = [];
+            if (dir !== root)
+                notes.push("intermediate/working directory file: read by Copilot CLI (documented); VS Code reads repository-root files");
+            if (n.rel === "GEMINI.md")
+                notes.push("read by Copilot CLI (documented); not listed for VS Code");
+            else if (cliOnly)
+                notes.push("read by Copilot CLI (documented); VS Code only with chat.useClaudeMdFile (setting not read)");
+            if (n.rel === "AGENTS.md" && dir === root)
+                notes.push("VS Code: chat.useAgentsMdFile, on by default (setting not read)");
+            if (!n.imports)
+                notes.push("@file references are not expanded in GEMINI.md by Copilot CLI (documented)");
+            if (isDup(f, jail))
+                continue;
+            const it = (0, common_1.loadInstruction)(ctx, f, {
+                agent: AGENT, scope: dir === ctx.cwd ? "project" : "ancestor", loadMode: "always", label: ctx.display(f), cardLabel: n.card, jail,
+                stripComments: false, imports: n.imports, importRoots: [root], importRelativeOnly: true,
+                confidence: "documented", evidence: ev(n.rel === ".github/copilot-instructions.md" ? "repoInstructions" : "cliInstructions"), notes,
+            });
+            const kept = it;
+            if (kept)
+                items.push(kept);
+        }
+    }
+    // Nested agent files below cwd: Copilot CLI picks them up for files it works on there -> conditional
+    for (const hit of ctx.walk().hits) {
+        if (hit.dir === ctx.cwd || !(0, fs_safe_1.isInside)(hit.dir, ctx.cwd))
+            continue;
+        for (const name of ["AGENTS.md", "CLAUDE.md", "GEMINI.md"]) {
+            if (!hit.names.includes(name))
+                continue;
+            const f = node_path_1.default.join(hit.dir, name);
+            if (isDup(f, ctx.jailFor(hit.dir)))
+                continue;
+            const it = (0, common_1.loadInstruction)(ctx, f, {
+                agent: AGENT, scope: "nested", loadMode: "conditional", label: ctx.display(f), cardLabel: `nested ${name}`, jail: ctx.jailFor(hit.dir),
+                stripComments: false, imports: name !== "GEMINI.md", importRoots: [root], importRelativeOnly: true, confidence: "documented", evidence: ev("cliInstructions"),
+                notes: ["applies when Copilot works on files in that directory"],
+            });
+            const kept = it;
+            if (kept)
+                items.push(kept);
+        }
+    }
+    // Path-specific *.instructions.md (repo root and cwd .github/instructions, not intermediate dirs; user ~/.copilot/instructions)
+    const instrDirs = [[node_path_1.default.join(root, ".github", "instructions"), "project", ctx.jailFor(root)]];
+    if (ctx.cwd !== root)
+        instrDirs.push([node_path_1.default.join(ctx.cwd, ".github", "instructions"), "project", ctx.jailFor(ctx.cwd)]);
+    instrDirs.push([node_path_1.default.join(home, "instructions"), "user", undefined]);
+    for (const [dir, scope, jail] of instrDirs) {
+        if (!(0, fs_safe_1.isDir)(dir))
+            continue;
+        for (const f of (0, common_1.listFilesRec)(dir, [".instructions.md"], 500, 8)) {
+            const r = ctx.read(f, jail ? { jail } : {});
+            if (!r.ok) {
+                items.push(...[(0, common_1.loadInstruction)(ctx, f, { agent: AGENT, scope, loadMode: "conditional", label: ctx.display(f), cardLabel: "instructions file", jail, stripComments: false, imports: false, confidence: "documented", evidence: ev("pathInstructions") })].filter((x) => !!x));
+                continue;
+            }
+            const fm = (0, frontmatter_1.parseFrontmatter)(r.text);
+            const applyTo = (0, frontmatter_1.asString)(fm.data.applyTo)?.trim();
+            const desc = (0, frontmatter_1.asString)(fm.data.description)?.trim();
+            let mode;
+            const notes = [];
+            if (applyTo) {
+                mode = "conditional";
+                const pats = applyTo.split(",").map((s) => s.trim()).filter(Boolean);
+                notes.push(`applyTo: ${pats.length} pattern${pats.length > 1 ? "s" : ""}; attached when Copilot creates or changes a matching file`);
+                if (pats.some((p) => p === "**" || p === "**/*"))
+                    notes.push("applyTo matches every file, so in practice it loads on nearly every edit");
+            }
+            else if (desc) {
+                mode = "deferred";
+                notes.push("no applyTo: VS Code may load it on demand when its description matches the task (documented)");
+            }
+            else {
+                ctx.exclude(AGENT, f, "no applyTo and no description: only used when attached manually");
+                continue;
+            }
+            const ex = (0, frontmatter_1.asString)(fm.data.excludeAgent);
+            if (ex)
+                notes.push(`excludeAgent: ${ex}`);
+            const it = (0, common_1.loadInstruction)(ctx, f, {
+                agent: AGENT, scope, loadMode: mode, label: ctx.display(f), cardLabel: "instructions file", jail, stripComments: false, imports: false,
+                confidence: "documented", evidence: ev("pathInstructions"), notes, group: `instr#${mode}`, groupLabel: mode === "conditional" ? "path-specific instructions (applyTo)" : "instructions loaded by description",
+                transform: (raw) => ({ text: (0, frontmatter_1.parseFrontmatter)(raw).body }), noAnalyze: true,
+            });
+            if (it)
+                items.push(it);
+        }
+    }
+    // Prompt files: slash commands, loaded only when invoked
+    const promptDir = node_path_1.default.join(root, ".github", "prompts");
+    if ((0, fs_safe_1.isDir)(promptDir)) {
+        for (const f of (0, common_1.listFilesRec)(promptDir, [".prompt.md"], 500, 8)) {
+            const it = (0, common_1.loadInstruction)(ctx, f, {
+                agent: AGENT, scope: "project", loadMode: "on-demand", label: ctx.display(f), cardLabel: "prompt file", jail: ctx.jailFor(root), stripComments: false, imports: false,
+                confidence: "documented", evidence: ev("promptFiles"), notes: ["prompt file: loaded only when you run it as a /command"], group: "prompts", groupLabel: "prompt files (/commands)",
+                transform: (raw) => ({ text: (0, frontmatter_1.parseFrontmatter)(raw).body }), noAnalyze: true,
+            });
+            if (it)
+                items.push(it);
+        }
+    }
+    // MCP. Precedence (closest wins): .mcp.json/.github/mcp.json cwd -> root, then ~/.copilot/mcp-config.json; VS Code files after.
+    const seenServer = new Set();
+    const addServers = (file, scope, defs, notes, doc) => {
+        for (const def of defs) {
+            if (def.disabled || seenServer.has(def.name))
+                continue;
+            seenServer.add(def.name);
+            items.push(...(0, common_1.mcpItems)(ctx, { agent: AGENT, def, source: file, scope, mode: "full", evidence: ev(doc), notes: ["Copilot MCP tool schemas modelled as loaded up front (unverified)", ...notes], index: items.length }));
+        }
+    };
+    const readMap = (file, jail) => {
+        if (!(0, fs_safe_1.isFile)(file))
+            return undefined;
+        const r = ctx.read(file, jail ? { jail } : {});
+        if (!r.ok)
+            return undefined;
+        try {
+            return JSON.parse(r.text);
+        }
+        catch {
+            ctx.warn(`${ctx.display(file)}: could not parse as JSON (comments are not supported here), skipped`);
+            return undefined;
+        }
+    };
+    const asMap = (j, key) => (j && typeof j === "object" && key in j ? j[key] : j);
+    for (const dir of [...chain].reverse()) {
+        for (const rel of [".mcp.json", ".github/mcp.json"]) {
+            if (rel === ".github/mcp.json" && dir !== root)
+                continue;
+            const f = node_path_1.default.join(dir, ...rel.split("/"));
+            const j = readMap(f, ctx.jailFor(dir));
+            if (j !== undefined)
+                addServers(f, "project", (0, configs_1.parseMcpMap)(asMap(j, "mcpServers"), (m) => ctx.warn(m)), ["project MCP config: loaded only after you trust the folder (assumed trusted)"], "cliMcp");
+        }
+    }
+    const userCfg = node_path_1.default.join(home, "mcp-config.json");
+    const uj = readMap(userCfg);
+    if (uj !== undefined)
+        addServers(userCfg, "user", (0, configs_1.parseMcpMap)(asMap(uj, "mcpServers"), (m) => ctx.warn(m)), [], "cliMcp");
+    for (const [f, scope] of [[node_path_1.default.join(root, ".vscode", "mcp.json"), "project"], [node_path_1.default.join(vscodeUserDir(ctx), "mcp.json"), "user"]]) {
+        const j = readMap(f, scope === "project" ? ctx.jailFor(root) : undefined);
+        if (j !== undefined)
+            addServers(f, scope, (0, configs_1.parseMcpMap)(j.servers, (m) => ctx.warn(m)), ["VS Code format (top-level \"servers\"): used by VS Code, not read by Copilot CLI (documented)"], "vscodeMcp");
+    }
+    return {
+        items,
+        unmeasuredBanner: [
+            "built-in system prompt and tools (incl. the built-in GitHub MCP server)",
+            "organization / enterprise instructions",
+            "VS Code settings (instruction files toggles, settings-based instructions) are not read; defaults assumed",
+            "skills and custom agents (not modelled yet)",
+        ],
+    };
+}

package/dist/adapters/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADAPTERS = void 0;
+const claude_code_1 = require("./claude-code");
+const cursor_1 = require("./cursor");
+const codex_1 = require("./codex");
+const github_copilot_1 = require("./github-copilot");
+const gemini_cli_1 = require("./gemini-cli");
+/** One adapter per id in src/agents.ts. A missing entry is a compile error. */
+exports.ADAPTERS = {
+    "claude-code": { detect: claude_code_1.detectClaude, discover: claude_code_1.discoverClaude },
+    cursor: { detect: cursor_1.detectCursor, discover: cursor_1.discoverCursor },
+    codex: { detect: codex_1.detectCodex, discover: codex_1.discoverCodex },
+    "github-copilot": { detect: github_copilot_1.detectCopilot, discover: github_copilot_1.discoverCopilot },
+    "gemini-cli": { detect: gemini_cli_1.detectGemini, discover: gemini_cli_1.discoverGemini },
+};

package/dist/adapters/skills.js

@@ -101,6 +101,16 @@ function skillItems(ctx, s) {
             group: s.group,
         });
         it.breakdown = per;
+        if (it.tokens && (s.lowLineFor || s.highLineFor)) {
+            const alt = (fn, tag) => {
+                const t = listed.map((l) => fn(l.r)).join("\n") + "\n";
+                return prof.apply(ctx.count(`skills-${tag}|${s.agent}|${s.dir}|${t.length}`, t));
+            };
+            if (s.lowLineFor)
+                it.tokens.low = Math.min(it.tokens.low, alt(s.lowLineFor, "lo").low);
+            if (s.highLineFor)
+                it.tokens.high = Math.max(it.tokens.high, alt(s.highLineFor, "hi").high);
+        }
         // "What to cut" parts: one per plugin (or, without a plugin, the whole group), scaled so they add up to the item's estimate.
         if (it.tokens) {
             const groups = new Map();

package/dist/agents.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_NAMES = exports.ALL_AGENTS = exports.AGENTS = void 0;
+exports.agentMeta = agentMeta;
+exports.AGENTS = [
+    {
+        id: "claude-code",
+        name: "Claude Code",
+        tokenFamily: "claude",
+        lookedFor: "~/.claude, ~/.claude.json, `claude` on PATH; CLAUDE.md, .claude/, .mcp.json in the project",
+        whereLooked: "CLAUDE.md (project, parent folders, ~/.claude), .claude/{rules,skills,commands}, plugins, .mcp.json, ~/.claude.json",
+        projectMarkers: ["CLAUDE.md", "CLAUDE.local.md", ".mcp.json", ".claude/"],
+    },
+    {
+        id: "cursor",
+        name: "Cursor",
+        tokenFamily: "mixed",
+        lookedFor: "~/.cursor, Cursor.app, `cursor` on PATH; .cursor/, .cursorrules, AGENTS.md in the project",
+        whereLooked: ".cursor/rules (incl. nested), AGENTS.md, .cursorrules, skills folders, ~/.cursor/{skills,plugins,mcp.json}, .cursor/mcp.json",
+        hint: "Cursor's User Rules live inside the app, not on disk. Paste them into a file and run with --paste-user-rules <file> to count them.",
+        cardChips: ["unmeasured: User Rules"],
+        projectMarkers: [".cursorrules", "AGENTS.md", ".cursor/"],
+    },
+    {
+        id: "codex",
+        name: "Codex",
+        tokenFamily: "openai",
+        lookedFor: "~/.codex, `codex` on PATH; AGENTS.md, .codex/, .agents/skills in the project",
+        whereLooked: "AGENTS.md chain, ~/.codex/{AGENTS.md,config.toml}, .agents/skills, ~/.agents/skills, .codex/config.toml",
+        projectMarkers: ["AGENTS.md", ".codex/", ".agents/"],
+    },
+    {
+        id: "github-copilot",
+        name: "GitHub Copilot",
+        tokenFamily: "mixed",
+        lookedFor: "~/.copilot, `copilot` on PATH, the VS Code Copilot Chat extension; .github/copilot-instructions.md, .github/instructions/, .github/prompts/, .vscode/mcp.json in the project",
+        whereLooked: ".github/copilot-instructions.md, AGENTS.md/CLAUDE.md/GEMINI.md (repo root → cwd), .github/instructions/**, .github/prompts/**, ~/.copilot/{copilot-instructions.md,instructions,mcp-config.json}, .mcp.json, .github/mcp.json, .vscode/mcp.json, VS Code user mcp.json",
+        hint: "Organization instructions and VS Code settings-based instructions live on GitHub or in VS Code settings, not in the scanned files.",
+        projectMarkers: [".github/copilot-instructions.md", ".github/instructions/", ".vscode/mcp.json"],
+    },
+    {
+        id: "gemini-cli",
+        name: "Gemini CLI",
+        tokenFamily: "gemini",
+        lookedFor: "~/.gemini, `gemini` on PATH; GEMINI.md, .gemini/ in the project",
+        whereLooked: "~/.gemini/GEMINI.md, GEMINI.md (cwd → project root, and below cwd), context.fileName, ~/.gemini/extensions/*, ~/.gemini/settings.json, .gemini/settings.json, .gemini/skills, .agents/skills",
+        projectMarkers: ["GEMINI.md", ".gemini/"],
+    },
+];
+exports.ALL_AGENTS = exports.AGENTS.map((a) => a.id);
+exports.AGENT_NAMES = Object.fromEntries(exports.AGENTS.map((a) => [a.id, a.name]));
+function agentMeta(id) {
+    return exports.AGENTS.find((a) => a.id === id);
+}