prehello 0.0.0-stage → 1.0.0

package/dist/adapters/codex.js

@@ -0,0 +1,184 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectCodex = detectCodex;
+exports.discoverCodex = discoverCodex;
+const node_path_1 = __importDefault(require("node:path"));
+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 fs_safe_2 = require("../fs-safe");
+const AGENT = "codex";
+const ev = (doc) => (0, spec_1.evidenceFor)(AGENT, doc);
+function codexHome(ctx) {
+    return ctx.opts.env.CODEX_HOME || node_path_1.default.join(ctx.home, ".codex");
+}
+function detectCodex(ctx) {
+    const by = [];
+    if ((0, fs_safe_1.isDir)(codexHome(ctx)))
+        by.push("config dir");
+    if ((0, fs_safe_1.onPath)("codex", ctx.opts.env.PATH ?? ctx.opts.env.Path, { platform: ctx.opts.platform, pathExt: ctx.opts.env.PATHEXT }))
+        by.push("binary on PATH");
+    const repo = [];
+    if ((0, fs_safe_1.isFile)(node_path_1.default.join(ctx.cwd, "AGENTS.md")))
+        repo.push(node_path_1.default.join(ctx.cwd, "AGENTS.md"));
+    if ((0, fs_safe_1.isFile)(node_path_1.default.join(ctx.cwd, "AGENTS.override.md")))
+        repo.push(node_path_1.default.join(ctx.cwd, "AGENTS.override.md"));
+    if ((0, fs_safe_1.isDir)(node_path_1.default.join(ctx.cwd, ".codex")))
+        repo.push(node_path_1.default.join(ctx.cwd, ".codex"));
+    return { detectedBy: by, repoFiles: repo };
+}
+function discoverCodex(ctx) {
+    const caps = (0, spec_1.loadSpec)(AGENT).caps;
+    const items = [];
+    const home = codexHome(ctx);
+    const cfgPath = node_path_1.default.join(home, "config.toml");
+    let cfg = {};
+    let servers = [];
+    const cfgText = ctx.read(cfgPath, { maxBytes: 5 * 1024 * 1024 });
+    if (cfgText.ok) {
+        try {
+            const p = (0, configs_1.parseCodexToml)(cfgText.text, (m) => ctx.warn(m));
+            cfg = p.config;
+            servers = p.servers;
+        }
+        catch {
+            ctx.warn(`${ctx.display(cfgPath)}: could not parse as TOML, skipped`);
+        }
+    }
+    const maxBytes = typeof cfg.project_doc_max_bytes === "number" && cfg.project_doc_max_bytes >= 0 ? cfg.project_doc_max_bytes : caps.projectDocMaxBytesDefault;
+    const fallbackNames = (Array.isArray(cfg.project_doc_fallback_filenames) ? cfg.project_doc_fallback_filenames : []).filter((x) => typeof x === "string" && x.length > 0 && !/[\\/]/.test(x) && x !== "." && x !== "..");
+    // Global: AGENTS.override.md else AGENTS.md (first non-empty)
+    for (const name of ["AGENTS.override.md", "AGENTS.md"]) {
+        const f = node_path_1.default.join(home, name);
+        const it = (0, common_1.loadInstruction)(ctx, f, { agent: AGENT, scope: "user", loadMode: "always", label: `~/.codex/${name}`, cardLabel: "global AGENTS.md", stripComments: false, imports: false, confidence: "documented", evidence: ev("agentsMd") });
+        if (it) {
+            items.push(it);
+            const shadowed = node_path_1.default.join(home, "AGENTS.md");
+            if (name === "AGENTS.override.md" && (0, fs_safe_1.isFile)(shadowed))
+                ctx.exclude(AGENT, shadowed, "shadowed by AGENTS.override.md in the same directory (Codex reads only one)");
+            break;
+        }
+    }
+    // Project chain: git root (or cwd) -> cwd; one file per dir: override -> AGENTS.md -> fallbacks
+    const root = ctx.gitRoot ?? ctx.cwd;
+    const chain = ctx.ancestorDirs().filter((d) => (0, fs_safe_1.isInside)(d, root));
+    let remaining = maxBytes;
+    for (const dir of chain) {
+        const names = ["AGENTS.override.md", "AGENTS.md", ...fallbackNames];
+        for (const name of names) {
+            const f = node_path_1.default.join(dir, name);
+            if (!(0, fs_safe_1.isFile)(f))
+                continue;
+            const jail = ctx.jailFor(dir);
+            const probe = ctx.read(f, { jail });
+            if (!probe.ok || !probe.text.trim())
+                continue;
+            if (remaining <= 0) {
+                ctx.exclude(AGENT, f, `beyond project_doc_max_bytes (${maxBytes} B): Codex stops reading AGENTS.md files here`);
+                break;
+            }
+            const bytes = Buffer.byteLength(probe.text);
+            const it = (0, common_1.loadInstruction)(ctx, f, {
+                agent: AGENT,
+                scope: dir === ctx.cwd ? "project" : "ancestor",
+                loadMode: "always",
+                label: ctx.display(f),
+                cardLabel: name === "AGENTS.md" ? "AGENTS.md" : name,
+                jail,
+                stripComments: false,
+                imports: false,
+                confidence: "documented",
+                evidence: ev("agentsMd"),
+                transform: (raw) => {
+                    if (bytes <= remaining)
+                        return { text: raw };
+                    const t = Buffer.from(raw).subarray(0, remaining).toString("utf8");
+                    ctx.addFinding({ id: "F12", severity: "warn", agent: AGENT, message: `${ctx.display(f)} is truncated by Codex at project_doc_max_bytes (${maxBytes} B): only the first ${remaining} of ${bytes} bytes load`, paths: [f], confidence: "high", fix: "Shorten the AGENTS.md chain or raise project_doc_max_bytes in ~/.codex/config.toml." });
+                    return { text: t, notes: [`truncated at project_doc_max_bytes: ${remaining}/${bytes} bytes loaded`] };
+                },
+            });
+            if (it) {
+                items.push(it);
+                remaining -= Math.min(bytes, remaining) + 2; // 2 bytes ~ separator between concatenated files
+                for (const other of names.slice(names.indexOf(name) + 1)) {
+                    const of = node_path_1.default.join(dir, other);
+                    if ((0, fs_safe_1.isFile)(of))
+                        ctx.exclude(AGENT, of, `shadowed by ${name} in the same directory (Codex reads at most one file per directory)`);
+                }
+            }
+            break; // max one file per directory
+        }
+    }
+    // nested AGENTS.md below cwd: Codex walks root -> cwd only
+    for (const hit of ctx.walk().hits) {
+        if (hit.names.includes("AGENTS.md"))
+            ctx.exclude(AGENT, node_path_1.default.join(hit.dir, "AGENTS.md"), "below the launch directory (Codex reads AGENTS.md root→cwd only)");
+    }
+    // MCP: global config.toml; project .codex/config.toml (trusted projects; assumed)
+    for (const def of servers) {
+        if (def.disabled)
+            continue;
+        items.push(...(0, common_1.mcpItems)(ctx, { agent: AGENT, def, source: cfgPath, scope: "user", mode: "full", evidence: ev("mcp"), notes: ["Codex MCP schema loading modelled as upfront (unverified)"], index: items.length }));
+    }
+    const projCfg = node_path_1.default.join(ctx.cwd, ".codex", "config.toml");
+    const pr = ctx.read(projCfg, { jail: ctx.jailFor(ctx.cwd) });
+    if (pr.ok) {
+        try {
+            for (const def of (0, configs_1.parseCodexToml)(pr.text, (m) => ctx.warn(m)).servers) {
+                if (def.disabled)
+                    continue;
+                items.push(...(0, common_1.mcpItems)(ctx, { agent: AGENT, def, source: projCfg, scope: "project", mode: "full", evidence: ev("mcp"), notes: ["project .codex/config.toml: only loaded for trusted projects (assumed)"], index: items.length }));
+            }
+        }
+        catch {
+            ctx.warn(`${ctx.display(projCfg)}: could not parse as TOML, skipped`);
+        }
+    }
+    // Skills. Documented: Codex scans .agents/skills from the working directory up to the repo root, plus ~/.agents/skills and /etc/codex/skills.
+    // The listing sent to the model is name + description + file path (documented); bodies load when a skill is used.
+    const disabled = new Set();
+    const sc = cfg.skills?.config;
+    if (Array.isArray(sc)) {
+        for (const e of sc) {
+            const x = e;
+            if (x && typeof x.path === "string" && x.enabled === false) {
+                const p = x.path.replace(/^~(?=[\\/]|$)/, ctx.home);
+                disabled.add((0, fs_safe_2.realpathOrSelf)(node_path_1.default.basename(p) === "SKILL.md" ? node_path_1.default.dirname(p) : p));
+            }
+        }
+    }
+    const seenSkill = new Set();
+    const codexLine = (r) => `- ${r.name}: ${r.desc} (file: ${r.file})`;
+    const emit = (dir, scope, tag, jail, confidence, note) => {
+        const recs = (0, skills_1.discoverSkills)(ctx, dir, jail ? { jail } : {}).filter((r) => {
+            if (seenSkill.has(r.realPath))
+                return false;
+            seenSkill.add(r.realPath);
+            if (disabled.has((0, fs_safe_2.realpathOrSelf)(node_path_1.default.dirname(r.file)))) {
+                ctx.exclude(AGENT, r.file, "disabled in config.toml ([[skills.config]] enabled = false)");
+                return false;
+            }
+            return true;
+        });
+        if (!recs.length)
+            return;
+        const its = (0, skills_1.skillItems)(ctx, { agent: AGENT, dir, scope, tag, recs, lineFor: codexLine, listingMode: "always", confidence, evidence: ev("skills"), notes: ["name + description + file path are listed up front (documented); the body loads when the skill is used", ...(note ? [note] : [])] });
+        items.push(...its);
+        const l = its.find((i) => i.kind === "skills-listing");
+        const budget = 0.02 * ctx.opts.window;
+        if (l?.tokens && l.tokens.est > budget) {
+            ctx.addFinding({ id: "F13", severity: "info", agent: AGENT, message: `${tag} skills listing (~${l.tokens.est} tokens) exceeds ≈2% of a ${ctx.opts.window / 1000}k window (~${Math.round(budget)}); Codex shortens descriptions to fit its skills budget (documented), so actual cost is lower but descriptions are lost`, paths: [dir], confidence: "low", fix: "Remove skills you do not use, or disable them with [[skills.config]] enabled = false." });
+        }
+    };
+    for (const dir of [...chain].reverse())
+        emit(node_path_1.default.join(dir, ".agents", "skills"), dir === ctx.cwd ? "project" : "ancestor", dir === ctx.cwd ? "project" : "ancestor", ctx.jailFor(dir), "documented");
+    emit(node_path_1.default.join(ctx.home, ".agents", "skills"), "user", "user", undefined, "documented");
+    emit(ctx.sys("/etc/codex/skills"), "managed", "admin (/etc/codex/skills)", undefined, "documented");
+    emit(node_path_1.default.join(home, "skills"), "user", "legacy ~/.codex", undefined, "assumed", "~/.codex/skills is read by Cursor and was the older Codex location; current Codex docs list ~/.agents/skills, so whether Codex still loads it is unverified");
+    return { items, unmeasuredBanner: ["built-in system prompt and tools", "Codex bundled system skills (~/.codex/skills/.system, hidden dirs are skipped)", "server-side / org instructions"] };
+}

package/dist/adapters/common.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadInstruction = loadInstruction;
+exports.listFilesRec = listFilesRec;
+exports.catalogFor = catalogFor;
+exports.mcpItems = mcpItems;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const context_1 = require("../context");
+const comments_1 = require("../text/comments");
+const imports_1 = require("../text/imports");
+const fs_safe_1 = require("../fs-safe");
+const catalog_1 = require("../mcp/catalog");
+/** Read one instruction-like file and turn it into an Item. Returns null if missing/unreadable/empty. */
+function loadInstruction(ctx, filePath, o) {
+    const r = ctx.read(filePath, o.jail ? { jail: o.jail } : {});
+    if (!r.ok) {
+        // The file exists but could not be measured: surface it as UNMEASURED so totals become lower bounds (never silently dropped).
+        if (r.reason === "missing" || r.reason === "not-file")
+            return null;
+        const why = r.reason === "budget" ? "not read: scan budget reached" : (0, context_1.readFailWhy)(r.reason, "not read");
+        return ctx.makeItem({
+            agent: o.agent, path: filePath, kind: o.kind ?? "instructions", scope: o.scope, loadMode: o.loadMode, raw: null,
+            unmeasuredReason: why, confidence: o.confidence, evidence: o.evidence, notes: [...(o.notes ?? [])],
+            cardLabel: o.cardLabel, label: o.label, group: o.group, groupLabel: o.groupLabel,
+        });
+    }
+    let text = r.text;
+    const notes = [...(o.notes ?? [])];
+    if (o.transform) {
+        const t = o.transform(text);
+        text = t.text;
+        notes.push(...(t.notes ?? []));
+    }
+    const afterTransform = text;
+    if (o.stripComments)
+        text = (0, comments_1.stripHtmlComments)(text);
+    let detail;
+    if (o.imports) {
+        const roots = (o.importRoots ?? [ctx.home, ctx.gitRoot ?? ctx.cwd, node_path_1.default.dirname(filePath)]).map(fs_safe_1.realpathOrSelf);
+        const res = (0, imports_1.expandImports)(text, filePath, ctx.home, (real) => roots.some((root) => (0, fs_safe_1.isInside)(real, root)), { stripComments: o.stripComments, read: (t) => ctx.read(t, { quiet: true }), maxDepth: o.importMaxDepth, relativeOnly: o.importRelativeOnly });
+        text = res.text;
+        if (res.imported)
+            detail = `(+${res.imported} @import${res.imported > 1 ? "s" : ""})`;
+        if (res.skipped.length)
+            notes.push(`${res.skipped.length} @import(s) not followed (${[...new Set(res.skipped.map((s) => s.reason))].join(", ")})`);
+    }
+    if (!text.trim())
+        return null;
+    const key = `${r.realPath}|${o.stripComments ? 1 : 0}${o.imports ? 1 : 0}|${o.importRoots ? o.importRoots.join(",") : ""}${o.importMaxDepth ?? ""}${o.importRelativeOnly ? "r" : ""}|${o.transform ? text.length : ""}`;
+    const raw = ctx.count(key, text);
+    if (!o.noAnalyze)
+        ctx.analyzeDoc(o.agent, filePath, r.text, afterTransform, raw, o.guidelineLines);
+    return ctx.makeItem({
+        agent: o.agent,
+        path: filePath,
+        kind: o.kind ?? "instructions",
+        scope: o.scope,
+        loadMode: o.loadMode,
+        raw,
+        chars: text.length,
+        lines: (0, context_1.lineCount)(r.text),
+        confidence: o.confidence,
+        evidence: o.evidence,
+        notes,
+        cardLabel: o.cardLabel,
+        label: o.label,
+        detail,
+        group: o.group,
+        groupLabel: o.groupLabel,
+    });
+}
+/** Recursively list files with an extension under dir (bounded, no symlink following). */
+function listFilesRec(dir, ext, limit = 500, maxDepth = 5) {
+    const out = [];
+    const visit = (d, depth) => {
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(d, { withFileTypes: true }).sort((a, b) => (a.name < b.name ? -1 : 1));
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (out.length >= limit)
+                return;
+            const p = node_path_1.default.join(d, e.name);
+            if (e.isSymbolicLink()) {
+                // allow symlinked files (resolved by jail in the reader) but not symlinked dirs
+                if (ext.some((x) => e.name.endsWith(x)))
+                    out.push(p);
+            }
+            else if (e.isDirectory() && depth < maxDepth)
+                visit(p, depth + 1);
+            else if (e.isFile() && ext.some((x) => e.name.endsWith(x)))
+                out.push(p);
+        }
+    };
+    visit(dir, 0);
+    return out;
+}
+let catalogCache;
+function catalogFor(ctx) {
+    const key = `${ctx.opts.noBundledCatalog ? "nb" : "b"}|${ctx.opts.catalogPath ?? ""}`;
+    if (!catalogCache || catalogCache.key !== key) {
+        const c = (0, catalog_1.loadCatalog)(ctx.opts.catalogPath, ctx.opts.noBundledCatalog);
+        catalogCache = { key, ...c };
+    }
+    catalogCache.warnings.forEach((w) => ctx.warn(w));
+    return catalogCache.entries;
+}
+/** Turn one configured MCP server into 1–2 items. Unmeasured servers are NEVER zero. */
+function mcpItems(ctx, b) {
+    const items = mcpItemsInner(ctx, b);
+    for (const it of items)
+        it.server = { name: b.def.name, transport: b.def.transport };
+    return items;
+}
+function mcpItemsInner(ctx, b) {
+    const entry = (0, catalog_1.lookup)(catalogFor(ctx), b.def);
+    const base = {
+        agent: b.agent,
+        path: b.source,
+        kind: "mcp-server",
+        scope: b.scope,
+        evidence: b.evidence,
+        cardLabel: "MCP server",
+        group: "mcp",
+        groupLabel: "MCP servers",
+    };
+    if (!entry) {
+        return [
+            ctx.makeItem({
+                ...base,
+                loadMode: "always",
+                raw: null,
+                unmeasuredReason: "no local tool-list cache or catalog entry; run is static (no server was started)",
+                confidence: "assumed",
+                notes: [...b.notes, `transport: ${b.def.transport}`],
+                label: `MCP server "${b.def.name}"`,
+            }),
+        ];
+    }
+    const tag = `catalog: measured ${entry.measuredAt}${entry.version ? ` v${entry.version}` : ""}, ${entry.tools} tools; your version may differ`;
+    if (b.mode === "split") {
+        return [
+            ctx.makeItem({ ...base, loadMode: "always", raw: entry.nameTokens, confidence: "assumed", notes: [...b.notes, tag, "tool names only (tool search)"], label: `MCP "${b.def.name}" (tool names)` }),
+            ctx.makeItem({ ...base, loadMode: "deferred", raw: entry.schemaTokens, confidence: "assumed", notes: [...b.notes, tag, "schemas fetched on demand (tool search)"], label: `MCP "${b.def.name}" (schemas)` }),
+        ];
+    }
+    return [
+        ctx.makeItem({ ...base, loadMode: "always", raw: entry.nameTokens + entry.schemaTokens, confidence: "assumed", notes: [...b.notes, tag], label: `MCP "${b.def.name}" (${entry.tools} tools)` }),
+    ];
+}

package/dist/adapters/cursor.js

@@ -0,0 +1,275 @@
+"use strict";
+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");
+const frontmatter_1 = require("../text/frontmatter");
+const common_1 = require("./common");
+const configs_1 = require("../mcp/configs");
+const skills_1 = require("./skills");
+const fmt_1 = require("../util/fmt");
+const AGENT = "cursor";
+const ev = (doc) => (0, spec_1.evidenceFor)(AGENT, doc);
+function detectCursor(ctx) {
+    const by = [];
+    if ((0, fs_safe_1.isDir)(node_path_1.default.join(ctx.home, ".cursor")))
+        by.push("~/.cursor");
+    if ((0, fs_safe_1.onPath)("cursor", ctx.opts.env.PATH ?? ctx.opts.env.Path, { platform: ctx.opts.platform, pathExt: ctx.opts.env.PATHEXT }))
+        by.push("binary on PATH");
+    if (ctx.opts.platform === "darwin" && ((0, fs_safe_1.isDir)(ctx.sys("/Applications/Cursor.app")) || (0, fs_safe_1.isDir)(node_path_1.default.join(ctx.home, "Applications", "Cursor.app"))))
+        by.push("Cursor.app");
+    if (ctx.opts.platform === "win32") {
+        // the per-user installer puts Cursor in %LOCALAPPDATA%\Programs\cursor; the system installer in %ProgramFiles%\cursor
+        const local = ctx.opts.env.LOCALAPPDATA || node_path_1.default.join(ctx.home, "AppData", "Local");
+        const pf = ctx.opts.env.ProgramFiles || "C:\\Program Files";
+        if ((0, fs_safe_1.isFile)(node_path_1.default.join(local, "Programs", "cursor", "Cursor.exe")) || (0, fs_safe_1.isFile)(ctx.sys(node_path_1.default.win32.join(pf, "cursor", "Cursor.exe"))))
+            by.push("Cursor.exe");
+    }
+    if (ctx.opts.pastedUserRules?.trim())
+        by.push("--paste-user-rules");
+    const repo = [];
+    for (const f of [".cursor", ".cursorrules"])
+        if ((0, fs_safe_1.isDir)(node_path_1.default.join(ctx.cwd, f)) || (0, fs_safe_1.isFile)(node_path_1.default.join(ctx.cwd, f)))
+            repo.push(node_path_1.default.join(ctx.cwd, f));
+    if ((0, fs_safe_1.isFile)(node_path_1.default.join(ctx.cwd, "AGENTS.md")))
+        repo.push(node_path_1.default.join(ctx.cwd, "AGENTS.md"));
+    return { detectedBy: by, repoFiles: repo };
+}
+function truthy(v) {
+    return v === true || (typeof v === "string" && v.trim().toLowerCase() === "true");
+}
+/** One .mdc rule file -> items, following the four documented Cursor rule modes. */
+function ruleFile(ctx, f, o, guideline) {
+    const items = [];
+    const r = ctx.read(f, o.jail ? { jail: o.jail } : {});
+    if (!r.ok)
+        return items;
+    const fm = (0, frontmatter_1.parseFrontmatter)(r.text);
+    const always = truthy(fm.data.alwaysApply);
+    const globs = (0, frontmatter_1.asList)(fm.data.globs);
+    const desc = (0, frontmatter_1.asString)(fm.data.description).trim();
+    const common = { agent: AGENT, path: f, kind: "rule", scope: o.scope, evidence: ev("rules"), cardLabel: o.conditional ? "nested rule file" : "rule file" };
+    const bodyRaw = ctx.count(`cursor-body|${r.realPath}`, fm.body);
+    if (!fm.body.trim() && !desc)
+        return items;
+    const up = o.conditional ? "conditional" : "always";
+    const conf = (c) => o.confidence ?? c;
+    const extra = o.note ? [o.note] : [];
+    let mode;
+    if (always) {
+        mode = "always";
+        items.push(ctx.makeItem({ ...common, loadMode: up, raw: bodyRaw, chars: fm.body.length, lines: fm.body.split("\n").length, confidence: conf("documented"), label: ctx.display(f), groupLabel: `${o.gl} (alwaysApply)`, notes: ["alwaysApply: true", ...extra], group: `${o.gl}#always` }));
+    }
+    else if (globs.length) {
+        mode = "conditional";
+        items.push(ctx.makeItem({ ...common, loadMode: "conditional", raw: bodyRaw, chars: fm.body.length, confidence: conf("documented"), label: ctx.display(f), groupLabel: `${o.gl} (glob-scoped)`, notes: [`globs: ${globs.length} pattern${globs.length > 1 ? "s" : ""}`, ...extra], group: `${o.gl}#glob` }));
+    }
+    else if (desc) {
+        mode = "description";
+        const draw = ctx.count(`cursor-desc|${r.realPath}`, desc);
+        items.push(ctx.makeItem({ ...common, loadMode: up, kind: "rule-description", raw: draw, chars: desc.length, confidence: "assumed", label: ctx.display(f) + " (description)", groupLabel: `${o.gl} descriptions (agent-requested)`, notes: ["description is visible so the agent can decide to fetch the rule; exact injection unverified", ...extra], group: `${o.gl}#desc` }), ctx.makeItem({ ...common, loadMode: "deferred", kind: "rule-body", raw: bodyRaw, chars: fm.body.length, confidence: "assumed", label: ctx.display(f) + " (body)", groupLabel: `${o.gl} bodies (agent-requested)`, notes: ["fetched only if the agent decides it is relevant", ...extra], group: `${o.gl}#body` }));
+    }
+    else {
+        mode = "manual";
+        items.push(ctx.makeItem({ ...common, loadMode: "on-demand", raw: bodyRaw, chars: fm.body.length, confidence: conf("documented"), label: ctx.display(f), groupLabel: `${o.gl} (manual @-mention)`, notes: ["no alwaysApply/globs/description: only via @-mention", ...extra], group: `${o.gl}#manual` }));
+    }
+    ctx.analyzeDoc(AGENT, f, r.text, fm.body, bodyRaw, mode === "always" && !o.conditional ? guideline : undefined);
+    return items;
+}
+function rulesIn(ctx, dir, o, guideline, allowMd) {
+    const items = [];
+    for (const f of (0, common_1.listFilesRec)(dir, [".mdc", ".md"])) {
+        if (f.endsWith(".md") && !allowMd) {
+            ctx.exclude(AGENT, f, "plain .md in .cursor/rules is ignored by Cursor (only .mdc is loaded)");
+            ctx.addFinding({ id: "F11", severity: "warn", agent: AGENT, message: `${ctx.display(f)} is ignored by Cursor: only .mdc files in .cursor/rules are loaded`, paths: [f], confidence: "high", fix: "Rename it to .mdc (and add frontmatter) if you intend Cursor to use it." });
+            continue;
+        }
+        items.push(...ruleFile(ctx, f, o, guideline));
+    }
+    return items;
+}
+const SKILLS_DOC = "skills";
+/** Cursor skill locations. Native dirs + compat dirs are documented; ~/.cursor/skills-cursor was OBSERVED on a real Mac, not documented. */
+function skillRoots(ctx) {
+    const h = ctx.home;
+    const c = ctx.cwd;
+    const compat = "also read by Cursor for compatibility (documented)";
+    return [
+        { dir: node_path_1.default.join(c, ".cursor", "skills"), scope: "project", tag: "project", project: true, confidence: "documented" },
+        { dir: node_path_1.default.join(c, ".agents", "skills"), scope: "project", tag: "project (.agents)", project: true, confidence: "documented" },
+        { dir: node_path_1.default.join(c, ".claude", "skills"), scope: "project", tag: "project (.claude)", project: true, confidence: "documented", note: compat },
+        { dir: node_path_1.default.join(c, ".codex", "skills"), scope: "project", tag: "project (.codex)", project: true, confidence: "documented", note: compat },
+        { dir: node_path_1.default.join(h, ".cursor", "skills"), scope: "user", tag: "user", project: false, confidence: "documented" },
+        { dir: node_path_1.default.join(h, ".agents", "skills"), scope: "user", tag: "user (.agents)", project: false, confidence: "documented" },
+        { dir: node_path_1.default.join(h, ".claude", "skills"), scope: "user", tag: "user (.claude)", project: false, confidence: "documented", note: compat },
+        { dir: node_path_1.default.join(h, ".codex", "skills"), scope: "user", tag: "user (.codex)", project: false, confidence: "documented", note: compat },
+        { dir: node_path_1.default.join(h, ".cursor", "skills-cursor"), scope: "builtin", tag: "Cursor-managed", project: false, confidence: "assumed", note: "~/.cursor/skills-cursor is not in Cursor's docs; it was observed on a real install and is assumed to hold Cursor's own built-in skills, listed like any other skill (listing format unverified)" },
+    ];
+}
+/** Plugin roots under ~/.cursor/plugins/{local,cache}. The on-disk layout is NOT documented: any directory holding a manifest counts. */
+function findCursorPlugins(ctx) {
+    const base = node_path_1.default.join(ctx.home, ".cursor", "plugins");
+    const found = [];
+    const hasManifest = (d) => (0, fs_safe_1.isFile)(node_path_1.default.join(d, ".cursor-plugin", "plugin.json")) || (0, fs_safe_1.isFile)(node_path_1.default.join(d, "plugin.json"));
+    const visit = (d, depth, origin) => {
+        if (found.length >= 200)
+            return;
+        if (hasManifest(d)) {
+            const mf = (0, fs_safe_1.isFile)(node_path_1.default.join(d, ".cursor-plugin", "plugin.json")) ? node_path_1.default.join(d, ".cursor-plugin", "plugin.json") : node_path_1.default.join(d, "plugin.json");
+            const j = ctx.readJson(mf);
+            const name = j && typeof j.name === "string" && j.name.trim() ? j.name.trim().slice(0, 80) : node_path_1.default.basename(d);
+            found.push({ name, root: d, origin });
+            return;
+        }
+        if (depth <= 0)
+            return;
+        for (const e of (0, fs_safe_1.listDir)(d)) {
+            if (e.name.startsWith("."))
+                continue;
+            const p = node_path_1.default.join(d, e.name);
+            if (e.isDirectory() || (e.isSymbolicLink() && (0, fs_safe_1.isDir)(p)))
+                visit(p, depth - 1, origin);
+        }
+    };
+    visit(node_path_1.default.join(base, "local"), 2, "local");
+    visit(node_path_1.default.join(base, "cache"), 5, "cache");
+    // same plugin name in several cached versions: keep the last path in sorted order (usually the newest version)
+    const byName = new Map();
+    for (const p of found.sort((a, b) => (0, fmt_1.cmp)(a.root, b.root)))
+        byName.set(p.name, p);
+    return [...byName.values()];
+}
+function discoverCursor(ctx) {
+    const caps = (0, spec_1.loadSpec)(AGENT).caps;
+    const items = [];
+    const jail = ctx.jailFor(ctx.cwd);
+    const banner = ["User Rules and Team Rules (stored in Cursor, not on disk; paste them with --paste-user-rules to count them)", "built-in system prompt and tools"];
+    // Rules: .mdc only; plain .md is ignored by Cursor
+    items.push(...rulesIn(ctx, node_path_1.default.join(ctx.cwd, ".cursor", "rules"), { scope: "project", jail, gl: ".cursor/rules" }, caps.ruleGuidelineLines, false));
+    // Legacy .cursorrules (assumed always)
+    const legacy = node_path_1.default.join(ctx.cwd, ".cursorrules");
+    const lit = (0, common_1.loadInstruction)(ctx, legacy, { agent: AGENT, scope: "project", loadMode: "always", label: ".cursorrules (legacy)", cardLabel: ".cursorrules", jail, stripComments: false, imports: false, confidence: "assumed", evidence: ev("rules"), notes: ["legacy format; still read as an always-on rule (unverified)"] });
+    if (lit)
+        items.push(lit);
+    // AGENTS.md: root always, nested conditional
+    const rootAgents = node_path_1.default.join(ctx.cwd, "AGENTS.md");
+    const rit = (0, common_1.loadInstruction)(ctx, rootAgents, { agent: AGENT, scope: "project", loadMode: "always", label: "AGENTS.md", cardLabel: "AGENTS.md", jail, stripComments: false, imports: false, confidence: "documented", evidence: ev("rules") });
+    if (rit)
+        items.push(rit);
+    const nestedDirs = [];
+    for (const hit of ctx.walk().hits) {
+        nestedDirs.push(hit);
+        if (!hit.names.includes("AGENTS.md"))
+            continue;
+        const nf = node_path_1.default.join(hit.dir, "AGENTS.md");
+        const it = (0, common_1.loadInstruction)(ctx, nf, { agent: AGENT, scope: "nested", loadMode: "conditional", label: ctx.display(nf), cardLabel: "nested AGENTS.md", jail: ctx.jailFor(hit.dir), stripComments: false, imports: false, confidence: "documented", evidence: ev("rules"), notes: ["nested AGENTS.md applies when working in that directory"] });
+        if (it)
+            items.push(it);
+    }
+    // Nested .cursor/rules in subdirectories. Sources conflict on whether Cursor loads these (docs describe project-root rules only;
+    // forum reports say subdirectory rules apply), so they are labelled "assumed" and counted as conditional.
+    for (const hit of nestedDirs) {
+        if (!hit.names.includes(".cursor/rules/"))
+            continue;
+        items.push(...rulesIn(ctx, node_path_1.default.join(hit.dir, ".cursor", "rules"), { scope: "nested", jail: ctx.jailFor(hit.dir), gl: "nested .cursor/rules", conditional: true, confidence: "assumed", note: "nested .cursor/rules: whether Cursor loads subdirectory rules is not stated in its docs (assumed conditional)" }, caps.ruleGuidelineLines, false));
+    }
+    // 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) => [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 : 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)
+            items.push(...(0, skills_1.skillItems)(ctx, { ...spec, tag: `${tag}, path-scoped`, recs: scoped, listingMode: "conditional", notes: cursorSkillNotes("skills with paths/globs frontmatter are surfaced only when matching files are in play (documented)") }));
+    };
+    for (const root of skillRoots(ctx)) {
+        const recs = (0, skills_1.discoverSkills)(ctx, root.dir, { recursive: true, ...(root.project ? { jail } : {}) });
+        emitSkills(recs, root.dir, root.scope, root.tag, root.confidence, root.note);
+    }
+    for (const hit of nestedDirs) {
+        for (const rel of [".cursor/skills/", ".agents/skills/"]) {
+            if (!hit.names.includes(rel))
+                continue;
+            const dir = node_path_1.default.join(hit.dir, ...rel.split("/").filter(Boolean));
+            emitSkills((0, skills_1.discoverSkills)(ctx, dir, { recursive: true, jail: ctx.jailFor(hit.dir) }), dir, "nested", "nested", "documented", "nested skill directories are scoped to their subtree (documented)", true);
+        }
+    }
+    // Plugins (skills / rules / mcp.json). Install state is not on a documented path: anything found in plugins/local or plugins/cache counts.
+    const plugins = findCursorPlugins(ctx);
+    const pluginNote = "plugin found under ~/.cursor/plugins; Cursor's on-disk plugin layout and install state are undocumented, so it may not be enabled (assumed)";
+    let pluginOtherComponents = 0;
+    const pluginSkillRecs = [];
+    for (const pl of plugins) {
+        const recs = (0, skills_1.discoverSkills)(ctx, node_path_1.default.join(pl.root, "skills"), { recursive: true });
+        for (const r of recs)
+            r.source = pl.name;
+        pluginSkillRecs.push(...recs);
+        items.push(...rulesIn(ctx, node_path_1.default.join(pl.root, "rules"), { scope: "plugin", gl: `plugin ${pl.name} rules`, confidence: "assumed", note: pluginNote }, caps.ruleGuidelineLines, true));
+        const mcpFile = node_path_1.default.join(pl.root, "mcp.json");
+        const j = ctx.readJson(mcpFile);
+        if (j) {
+            for (const def of (0, configs_1.parseMcpMap)(j.mcpServers ?? j, (m) => ctx.warn(m))) {
+                if (def.disabled)
+                    continue;
+                items.push(...(0, common_1.mcpItems)(ctx, { agent: AGENT, def, source: mcpFile, scope: "plugin", mode: "split", evidence: ev("mcpLazy"), notes: [pluginNote, "Cursor keeps only tool names in static context (documented)"], index: items.length }));
+            }
+        }
+        if (["agents", "commands", "hooks"].some((d) => (0, fs_safe_1.isDir)(node_path_1.default.join(pl.root, d))))
+            pluginOtherComponents++;
+    }
+    if (pluginSkillRecs.length)
+        emitSkills(pluginSkillRecs, node_path_1.default.join(ctx.home, ".cursor", "plugins"), "plugin", `from ${plugins.length} plugin${plugins.length > 1 ? "s" : ""}`, "assumed", pluginNote);
+    if (plugins.length)
+        banner.push(`plugin install state (${plugins.length} plugin${plugins.length > 1 ? "s" : ""} found under ~/.cursor/plugins${(0, fs_safe_1.isDir)(node_path_1.default.join(ctx.home, ".cursor", "plugins", "marketplaces")) ? "; marketplace clones ignored" : ""})`);
+    if (pluginOtherComponents)
+        banner.push(`plugin agents/commands/hooks (${pluginOtherComponents} plugin${pluginOtherComponents > 1 ? "s" : ""})`);
+    // MCP: ~/.cursor/mcp.json and .cursor/mcp.json. Cursor keeps only tool NAMES in static context and fetches descriptions on demand (documented, Jan 2026).
+    for (const [file, scope] of [[node_path_1.default.join(ctx.home, ".cursor", "mcp.json"), "user"], [node_path_1.default.join(ctx.cwd, ".cursor", "mcp.json"), "project"]]) {
+        const j = ctx.readJson(file);
+        if (!j)
+            continue;
+        for (const def of (0, configs_1.parseMcpMap)(j.mcpServers, (m) => ctx.warn(m))) {
+            if (def.disabled)
+                continue;
+            items.push(...(0, common_1.mcpItems)(ctx, { agent: AGENT, def, source: file, scope, mode: "split", evidence: ev("mcpLazy"), notes: ["Cursor keeps only tool names in static context; descriptions are fetched on demand (documented in Cursor's 'Dynamic context discovery' post). Name count is unmeasured without a catalog entry."], index: items.length }));
+        }
+    }
+    // Pasted User Rules (they live inside the app, not on disk)
+    if (ctx.opts.pastedUserRules !== undefined && ctx.opts.pastedUserRules.trim()) {
+        const text = ctx.opts.pastedUserRules;
+        items.push(ctx.makeItem({ agent: AGENT, path: node_path_1.default.join(ctx.home, ".cursor", "(pasted user rules)"), kind: "user-rules", scope: "user", loadMode: "always", raw: ctx.count(`pasted|${text.length}`, text), chars: text.length, lines: text.split("\n").length, confidence: "assumed", evidence: ev("rules"), cardLabel: "User Rules (pasted)", label: "User Rules (pasted via --paste-user-rules)", notes: ["text you pasted; assumed to be sent on every request (Cursor docs describe User Rules as always applied; exact injection unverified)"] }));
+        const i = banner.findIndex((b) => b.startsWith("User Rules"));
+        if (i >= 0)
+            banner[i] = "Team Rules (stored in Cursor, not on disk)";
+    }
+    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>`;
+}