@esneiderbravo/speclaw 0.3.13 → 1.0.0

package/dist/modules/compass/register.js

@@ -1,19 +1,17 @@
 import { z } from "zod";
-import { defineTool, text } from "../../shared/mcp.js";
+import { defineTool, defineAliasTool, text } from "../../shared/mcp.js";
 import { shouldExpose } from "../../shared/exposure.js";
+import { aliasesEnabled } from "../../shared/tool-catalog.js";
+import { logDeprecatedCall, prefixDeprecated } from "../../shared/deprecation.js";
 import { buildIndex } from "./indexer.js";
-import { explore, search, recall, impact, trace } from "./query.js";
+import { impact } from "./query.js";
 import { affectedTests } from "./affected.js";
 import { hotspots, coupling } from "./hotspots.js";
 import { startWatch, stopWatch, watchStatus } from "./watcher.js";
-import { visualize } from "./visualize.js";
-// ─── Compass: speclaw's own code-intelligence engine (no external deps) ───
-/**
- * Register Compass MCP tools on the given server.
- *
- * @param server - The MCP server to register on.
- * @param opts - Exposure options (`minimal` omits setup/specialized tools).
- */
+import { exploreRich, findSymbols, formatExploreRich, } from "./explore-rich.js";
+import { diffContext, formatDiffContext } from "./diff-context.js";
+const includeEnum = z.array(z.enum(["source", "callers", "callees", "blast_radius", "tests", "hotspot"]));
+/** Register Compass MCP tools on the given server. */
 export function registerCompass(server, opts = {}) {
     const minimal = Boolean(opts.minimal);
     const add = (name, description, inputSchema, handler) => {
@@ -21,78 +19,174 @@ export function registerCompass(server, opts = {}) {
             return;
         defineTool(server, { name, description, inputSchema, handler });
     };
-    add("compass_index", "Build or refresh the local code graph index. Run once per project, then on demand.", { projectPath: z.string() }, async ({ projectPath }) => text(await buildIndex(projectPath)));
-    add("compass_explore", "Read a symbol's source plus callers and callees. Prefer this before grep or Read.", { projectPath: z.string(), node: z.string() }, async ({ projectPath, node }) => text(explore(projectPath, node)));
-    add("compass_search", "Find symbols by name or keyword (substring). Cheaper structural search than grep.", { projectPath: z.string(), query: z.string(), limit: z.number().optional() }, async ({ projectPath, query, limit }) => text(search(projectPath, query, limit ?? 25)));
-    add("compass_recall", "Find symbols by meaning via local embeddings. Use when names are unknown.", { projectPath: z.string(), query: z.string(), limit: z.number().optional() }, async ({ projectPath, query, limit }) => text(await recall(projectPath, query, limit ?? 15)));
-    add("compass_impact", "Blast radius for a symbol or files, grouped by module (not a flat dump).", {
+    add("compass_explore", "Symbol context in one call: source, callers, callees, blast radius, tests, hotspot. Prefer before grep.", {
         projectPath: z.string(),
-        /** @deprecated Prefer `symbol`. Kept for existing callers. */
-        node: z.string().optional(),
-        symbol: z.string().optional(),
-        files: z.array(z.string()).optional(),
-        nodeId: z.number().int().optional(),
-        maxDepth: z.number().int().min(1).max(12).optional(),
-        edgeKinds: z.array(z.enum(["call", "import"])).optional(),
-        target: z.enum(["build", "test", "lint", "any"]).optional(),
-        format: z.enum(["grouped", "flat"]).optional(),
-        topModules: z.number().int().min(1).max(50).optional(),
-        topPerModule: z.number().int().min(1).max(50).optional(),
-    }, async (args) => text(impact(args.projectPath, {
-        symbol: args.symbol ?? args.node,
-        files: args.files,
-        nodeId: args.nodeId,
-        maxDepth: args.maxDepth ?? 4,
-        edgeKinds: args.edgeKinds,
-        target: args.target,
-        format: args.format ?? "grouped",
-        topModules: args.topModules,
-        topPerModule: args.topPerModule,
-    })));
-    add("compass_affected_tests", "Select test files affected by a change; returns a ready-to-run command.", {
-        projectPath: z.string(),
-        files: z.array(z.string()).optional(),
-        symbols: z.array(z.string()).optional(),
-        fromDiff: z.string().optional(),
-        maxDepth: z.number().int().min(1).max(12).optional(),
-    }, async ({ projectPath, files, symbols, fromDiff, maxDepth }) => text(affectedTests(projectPath, { files, symbols, fromDiff, maxDepth })));
-    add("compass_hotspots", "Rank files by recent churn and AST complexity; two axes, no magic score.", {
-        projectPath: z.string(),
-        days: z.number().int().min(1).max(3650).optional(),
-        since: z.string().optional(),
-        sortBy: z.enum(["churn", "complexity", "combined"]).optional(),
-        limit: z.number().int().min(1).max(200).optional(),
-    }, async ({ projectPath, days, since, sortBy, limit }) => text(hotspots(projectPath, { days, since, sortBy, limit })));
-    add("compass_coupling", "Files that co-change with a target; strength, graph edge, and test-pair facts.", {
-        projectPath: z.string(),
-        file: z.string(),
-        days: z.number().int().min(1).max(3650).optional(),
-        since: z.string().optional(),
-        minShared: z.number().int().min(1).optional(),
-        maxFilesPerCommit: z.number().int().min(2).optional(),
-        limit: z.number().int().min(1).max(200).optional(),
-    }, async ({ projectPath, file, days, since, minShared, maxFilesPerCommit, limit }) => text(coupling(projectPath, file, { days, since, minShared, maxFilesPerCommit, limit })));
-    add("compass_trace", "Find a call path between two symbols within a depth limit.", {
-        projectPath: z.string(),
-        from: z.string(),
-        to: z.string(),
-        maxDepth: z.number().optional(),
-    }, async ({ projectPath, from, to, maxDepth }) => text(trace(projectPath, from, to, maxDepth ?? 8)));
-    add("compass_visualize", "Write an offline HTML graph to .speclaw/graph.html for interactive exploration.", {
+        node: z.string(),
+        to: z.string().optional(),
+        include: includeEnum.optional(),
+        mode: z.enum(["brief", "full"]).optional(),
+        maxDepth: z.number().int().min(1).max(8).optional(),
+    }, async ({ projectPath, node, to, include, mode, maxDepth }) => {
+        const result = await exploreRich({
+            projectPath,
+            node,
+            to,
+            include: include,
+            mode: (mode ?? "brief"),
+            maxDepth,
+        });
+        return text(formatExploreRich(result, (mode ?? "brief")));
+    });
+    add("compass_find", "Hybrid search over the index: BM25, vectors, and name match. mode sets weights; pass focus for edited files.", {
         projectPath: z.string(),
-        node: z.string().optional(),
-        depth: z.number().optional(),
+        query: z.string(),
+        mode: z.enum(["exact", "concept"]),
         limit: z.number().optional(),
-    }, async ({ projectPath, node, depth, limit }) => text(visualize(projectPath, { focus: node, depth, limit })));
-    add("compass_watch", "Start, stop, or status a debounced file watcher that re-indexes on change.", {
+        focus: z.array(z.string()).optional(),
+        maxTokens: z.number().int().min(256).max(32_000).optional(),
+    }, async ({ projectPath, query, mode, limit, focus, maxTokens }) => text(JSON.stringify(await findSymbols(projectPath, query, mode, limit, { focus, maxTokens }), null, 2)));
+    add("compass_diff_context", "Graph context of changes in one call: symbols, blast radius, tests, hotspots. Default: working tree.", {
+        projectPath: z.string(),
+        rev: z.string().optional(),
+        paths: z.array(z.string()).optional(),
+        mode: z.enum(["brief", "full"]).optional(),
+        maxDepth: z.number().int().min(1).max(8).optional(),
+    }, async ({ projectPath, rev, paths, mode, maxDepth }) => {
+        const result = diffContext({
+            projectPath,
+            rev,
+            paths,
+            mode: (mode ?? "brief"),
+            maxDepth,
+        });
+        return text(formatDiffContext(result, (mode ?? "brief")));
+    });
+    add("compass_index", "Build or refresh the code graph index; optional watch action for live re-index.", {
         projectPath: z.string(),
-        action: z.enum(["start", "stop", "status"]),
-    }, async ({ projectPath, action }) => {
-        const result = action === "start"
+        action: z.enum(["index", "start", "stop", "status"]).optional(),
+        force: z.boolean().optional(),
+        prune: z.boolean().optional(),
+    }, async ({ projectPath, action, force, prune }) => {
+        const act = action ?? "index";
+        if (act === "index")
+            return text(await buildIndex(projectPath, { force, prune }));
+        const result = act === "start"
             ? startWatch(projectPath)
-            : action === "stop"
+            : act === "stop"
                 ? stopWatch(projectPath)
                 : watchStatus(projectPath);
         return text(result);
     });
+    if (minimal || !aliasesEnabled())
+        return;
+    defineAliasTool(server, {
+        name: "compass_search",
+        description: "Deprecated alias for compass_find mode exact.",
+        inputSchema: { projectPath: z.string(), query: z.string(), limit: z.number().optional() },
+        handler: async ({ projectPath, query, limit }) => {
+            logDeprecatedCall(projectPath, "compass_search");
+            const body = JSON.stringify(await findSymbols(projectPath, query, "exact", limit), null, 2);
+            return text(prefixDeprecated("compass_search", body));
+        },
+    });
+    defineAliasTool(server, {
+        name: "compass_recall",
+        description: "Deprecated alias for compass_find mode concept.",
+        inputSchema: { projectPath: z.string(), query: z.string(), limit: z.number().optional() },
+        handler: async ({ projectPath, query, limit }) => {
+            logDeprecatedCall(projectPath, "compass_recall");
+            const body = JSON.stringify(await findSymbols(projectPath, query, "concept", limit), null, 2);
+            return text(prefixDeprecated("compass_recall", body));
+        },
+    });
+    defineAliasTool(server, {
+        name: "compass_impact",
+        description: "Deprecated alias for compass_explore blast_radius include.",
+        inputSchema: {
+            projectPath: z.string(),
+            node: z.string().optional(),
+            symbol: z.string().optional(),
+            files: z.array(z.string()).optional(),
+            maxDepth: z.number().optional(),
+        },
+        handler: async (args) => {
+            logDeprecatedCall(args.projectPath, "compass_impact");
+            const sym = args.symbol ?? args.node;
+            const body = sym
+                ? JSON.stringify(await exploreRich({
+                    projectPath: args.projectPath,
+                    node: sym,
+                    include: ["blast_radius"],
+                }), null, 2)
+                : JSON.stringify(impact(args.projectPath, { files: args.files, maxDepth: args.maxDepth ?? 4 }), null, 2);
+            return text(prefixDeprecated("compass_impact", body));
+        },
+    });
+    defineAliasTool(server, {
+        name: "compass_trace",
+        description: "Deprecated alias for compass_explore with to parameter.",
+        inputSchema: {
+            projectPath: z.string(),
+            from: z.string(),
+            to: z.string(),
+            maxDepth: z.number().optional(),
+        },
+        handler: async ({ projectPath, from, to, maxDepth }) => {
+            logDeprecatedCall(projectPath, "compass_trace");
+            const body = JSON.stringify(await exploreRich({ projectPath, node: from, to, maxDepth }), null, 2);
+            return text(prefixDeprecated("compass_trace", body));
+        },
+    });
+    defineAliasTool(server, {
+        name: "compass_affected_tests",
+        description: "Deprecated alias — use compass_diff_context or explore.",
+        inputSchema: {
+            projectPath: z.string(),
+            files: z.array(z.string()).optional(),
+            symbols: z.array(z.string()).optional(),
+            fromDiff: z.string().optional(),
+        },
+        handler: async (args) => {
+            logDeprecatedCall(args.projectPath, "compass_affected_tests");
+            const body = JSON.stringify(affectedTests(args.projectPath, args), null, 2);
+            return text(prefixDeprecated("compass_affected_tests", body));
+        },
+    });
+    defineAliasTool(server, {
+        name: "compass_hotspots",
+        description: "Deprecated alias — use compass_explore hotspot include.",
+        inputSchema: { projectPath: z.string(), limit: z.number().optional() },
+        handler: async ({ projectPath, limit }) => {
+            logDeprecatedCall(projectPath, "compass_hotspots");
+            const body = JSON.stringify(hotspots(projectPath, { limit }), null, 2);
+            return text(prefixDeprecated("compass_hotspots", body));
+        },
+    });
+    defineAliasTool(server, {
+        name: "compass_coupling",
+        description: "Deprecated alias — use compass_diff_context.",
+        inputSchema: { projectPath: z.string(), file: z.string() },
+        handler: async ({ projectPath, file }) => {
+            logDeprecatedCall(projectPath, "compass_coupling");
+            const body = JSON.stringify(coupling(projectPath, file, {}), null, 2);
+            return text(prefixDeprecated("compass_coupling", body));
+        },
+    });
+    defineAliasTool(server, {
+        name: "compass_watch",
+        description: "Deprecated alias for compass_index watch actions.",
+        inputSchema: {
+            projectPath: z.string(),
+            action: z.enum(["start", "stop", "status"]),
+        },
+        handler: async ({ projectPath, action }) => {
+            logDeprecatedCall(projectPath, "compass_watch");
+            const result = action === "start"
+                ? startWatch(projectPath)
+                : action === "stop"
+                    ? stopWatch(projectPath)
+                    : watchStatus(projectPath);
+            return text(prefixDeprecated("compass_watch", JSON.stringify(result, null, 2)));
+        },
+    });
 }

package/dist/modules/foundation/check.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { performance } from "node:perf_hooks";
-import { compileScope, hasBackend, manifestPath, matchCompiled, readLawManifest, } from "./laws.js";
+import { compileScope, hasBackend, isActiveLaw, manifestPath, matchCompiled, readLawManifest, } from "./laws.js";
 const cache = new Map();
 /**
  * Load the project's compiled law index, using the in-process cache when the
@@ -24,7 +24,9 @@ function loadLaws(projectPath) {
     const manifest = readLawManifest(projectPath);
     if (!manifest)
         return null;
-    const laws = manifest.laws.map((law) => ({ law, scope: compileScope(law.scope) }));
+    const laws = manifest.laws
+        .filter(isActiveLaw)
+        .map((law) => ({ law, scope: compileScope(law.scope) }));
     cache.set(projectPath, { mtimeMs, laws });
     return laws;
 }

package/dist/modules/foundation/compile-laws.js

@@ -0,0 +1,212 @@
+import fs from "node:fs";
+import path from "node:path";
+import { globError, isActiveLaw, readLawManifest, seedManifest, writeLawManifest, } from "./laws.js";
+import { parseLawsFromStandards } from "./laws-parse.js";
+import { agentsmdDialect, claudeRulesDialect, coderabbitDialect, copilotDialect, cursorMdcDialect, patchDelimited, } from "./dialects/index.js";
+import { detectConfiguredAgents } from "../../shared/agents.js";
+import { digestText, provenanceBlock, refreshLockfile } from "./lock.js";
+const DIALECTS = [
+    claudeRulesDialect,
+    cursorMdcDialect,
+    copilotDialect,
+    coderabbitDialect,
+    agentsmdDialect,
+];
+/**
+ * Merge seed + standards parse + on-disk manifest. Manifest wins on id conflict.
+ * Throws if standards declare duplicate ids.
+ */
+export function mergeLawSources(projectPath) {
+    const parsed = parseLawsFromStandards(projectPath);
+    if (parsed.duplicates.size > 0) {
+        const detail = [...parsed.duplicates.entries()]
+            .map(([id, locs]) => `${id} at ${locs.join(" and ")}`)
+            .join("; ");
+        throw new Error(`duplicate law id(s) in docs/standards: ${detail}`);
+    }
+    const byId = new Map();
+    for (const law of seedManifest().laws)
+        byId.set(law.id, law);
+    for (const law of parsed.laws) {
+        if (!byId.has(law.id))
+            byId.set(law.id, law);
+    }
+    const disk = readLawManifest(projectPath);
+    if (disk) {
+        for (const law of disk.laws)
+            byId.set(law.id, law);
+    }
+    return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+function validateScopes(laws) {
+    for (const law of laws) {
+        if (!isActiveLaw(law))
+            continue;
+        for (const p of law.scope) {
+            const err = globError(p);
+            if (err) {
+                throw new Error(`${law.id}: invalid scope ${JSON.stringify(p)} (${err}) — ${law.source.file}${law.source.line ? `:${law.source.line}` : ""}`);
+            }
+        }
+    }
+}
+function writeIfChanged(projectPath, abs, contents, report) {
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    const rel = path.relative(projectPath, abs).split(path.sep).join("/");
+    if (fs.existsSync(abs)) {
+        const prev = fs.readFileSync(abs, "utf8");
+        if (prev === contents) {
+            report.unchanged.push(rel);
+            return;
+        }
+    }
+    fs.writeFileSync(abs, contents);
+    report.written.push(rel);
+}
+/** Append a data-only provenance block when missing; body digest stays stable. */
+function withProvenance(contents, lawIds) {
+    const body = contents.replace(/<!-- speclaw:begin-provenance[\s\S]*?speclaw:end-provenance -->\n?/g, "");
+    const dig = digestText(body);
+    const base = body.endsWith("\n") ? body : body + "\n";
+    return base + provenanceBlock({ lawIds, digest: dig, source: "compile" });
+}
+function mergeCoderabbit(projectPath, abs, payloadJson, report) {
+    const payload = JSON.parse(payloadJson);
+    let text = fs.existsSync(abs)
+        ? fs.readFileSync(abs, "utf8")
+        : "reviews:\n  path_instructions: []\n";
+    const start = "# speclaw:path_instructions:start";
+    const end = "# speclaw:path_instructions:end";
+    const blockLines = [start];
+    for (const e of payload.path_instructions) {
+        blockLines.push(`  - path: ${JSON.stringify(e.path)}`);
+        blockLines.push(`    instructions: ${JSON.stringify(e.instructions)}`);
+    }
+    blockLines.push(end);
+    const block = blockLines.join("\n");
+    const re = /# speclaw:path_instructions:start[\s\S]*?# speclaw:path_instructions:end/;
+    if (re.test(text))
+        text = text.replace(re, block);
+    else {
+        if (!/path_instructions\s*:/.test(text)) {
+            if (!/^reviews\s*:/m.test(text))
+                text = `reviews:\n  path_instructions: []\n` + text;
+            else
+                text = text.replace(/^(reviews\s*:)/m, `$1\n  path_instructions: []`);
+        }
+        text = text.trimEnd() + "\n" + block + "\n";
+    }
+    writeIfChanged(projectPath, abs, text.endsWith("\n") ? text : text + "\n", report);
+}
+function ensureClaudeRulesSymlink(projectPath, report) {
+    const link = path.join(projectPath, ".claude", "rules", "speclaw");
+    const target = path.join("..", "..", "ai-specs", "rules");
+    fs.mkdirSync(path.dirname(link), { recursive: true });
+    try {
+        if (fs.lstatSync(link).isSymbolicLink() || fs.existsSync(link)) {
+            report.unchanged.push(".claude/rules/speclaw");
+            return;
+        }
+    }
+    catch {
+        /* missing */
+    }
+    try {
+        fs.symlinkSync(target, link);
+        report.written.push(".claude/rules/speclaw");
+    }
+    catch (err) {
+        report.failed.push({ path: ".claude/rules/speclaw", error: err.message });
+    }
+}
+function applyArtifact(projectPath, art, report) {
+    const abs = path.join(projectPath, art.path);
+    try {
+        if (art.mode === "write") {
+            // Nested AGENTS: only write if parent has package.json
+            if (art.path.endsWith("/AGENTS.md") && art.path !== "AGENTS.md") {
+                const dir = path.dirname(abs);
+                if (!fs.existsSync(path.join(dir, "package.json")))
+                    return;
+            }
+            const body = art.path.endsWith(".md") || art.path.endsWith(".mdc")
+                ? withProvenance(art.contents, art.lawIds)
+                : art.contents;
+            writeIfChanged(projectPath, abs, body, report);
+            return;
+        }
+        if (art.mode === "patch-delimited") {
+            const prev = fs.existsSync(abs) ? fs.readFileSync(abs, "utf8") : "";
+            const next = patchDelimited(prev, art.marker ?? "laws", art.contents);
+            writeIfChanged(projectPath, abs, next, report);
+            return;
+        }
+        if (art.mode === "merge-yaml-path-instructions") {
+            mergeCoderabbit(projectPath, abs, art.contents, report);
+        }
+    }
+    catch (err) {
+        report.failed.push({ path: art.path, error: err.message });
+    }
+}
+/**
+ * Compile project laws into agent dialects. Deterministic and idempotent.
+ */
+export function compileLaws(opts) {
+    const projectPath = opts.projectPath;
+    const report = {
+        schemaVersion: 1,
+        written: [],
+        unchanged: [],
+        failed: [],
+        lawCount: 0,
+        draftCount: 0,
+    };
+    const laws = mergeLawSources(projectPath);
+    validateScopes(laws);
+    report.lawCount = laws.filter(isActiveLaw).length;
+    report.draftCount = laws.filter((l) => !isActiveLaw(l)).length;
+    if (opts.writeManifest !== false) {
+        const manifest = { version: 1, laws };
+        writeLawManifest(projectPath, manifest);
+    }
+    const agents = opts.agents ?? detectConfiguredAgents(projectPath);
+    const ctx = { projectPath, agents };
+    const artifacts = [];
+    for (const d of DIALECTS)
+        artifacts.push(...d.compile(laws, ctx));
+    // Filter nested AGENTS without package.json before write
+    for (const art of artifacts) {
+        if (art.path.endsWith("/AGENTS.md") && art.path !== "AGENTS.md") {
+            const dir = path.join(projectPath, path.dirname(art.path));
+            if (!fs.existsSync(path.join(dir, "package.json")))
+                continue;
+        }
+        applyArtifact(projectPath, art, report);
+    }
+    if (agents.includes("claude"))
+        ensureClaudeRulesSymlink(projectPath, report);
+    // Covers: req~lock-refresh-update~1
+    try {
+        refreshLockfile(projectPath);
+    }
+    catch {
+        // Lock refresh must not fail compile; `speclaw laws lock` surfaces errors.
+    }
+    return report;
+}
+/** Estimate always-on tokens (empty scope) with a bytes/3.6 heuristic. */
+export function estimateAlwaysOnTokens(laws) {
+    const HEADER = 12;
+    const scored = laws
+        .filter((l) => isActiveLaw(l) && l.scope.length === 0)
+        .map((l) => ({
+        id: l.id,
+        tokens: Math.ceil(Buffer.byteLength(l.prose, "utf8") / 3.6) + HEADER,
+    }))
+        .sort((a, b) => b.tokens - a.tokens);
+    return {
+        total: scored.reduce((s, x) => s + x.tokens, 0),
+        top: scored.slice(0, 3),
+    };
+}

package/dist/modules/foundation/context-budget.js

@@ -1,22 +1,12 @@
-import { z } from "zod";
 import { registerCompass } from "../compass/register.js";
 import { registerSpec } from "../lawbook/register.js";
 import { registerTools } from "../tools/register.js";
 import { registerFoundationCore } from "./register-core.js";
 import { measureBudget } from "../../shared/budget.js";
-import { isMinimalMode, packageRoot, shouldExpose } from "../../shared/exposure.js";
-/** Mirrors the `doctor` tool surface without importing `doctor.ts` (avoids a cycle). */
-const DOCTOR_TOOL_FOR_BUDGET = {
-    name: "doctor",
-    description: "Verify the speclaw install; returns a versioned DoctorReport (schemaVersion 1).",
-    inputSchema: { projectPath: z.string() },
-};
+import { isMinimalMode, packageRoot } from "../../shared/exposure.js";
 /**
  * Collect tool definitions as the MCP server would register them for a profile.
  *
- * Uses `registerFoundationCore` plus a static `doctor` stub so budget/doctor
- * measurement never imports the live `doctor` implementation (module cycle).
- *
  * @param minimal - Exposure profile.
  */
 export function collectRegisteredTools(minimal) {
@@ -33,9 +23,6 @@ export function collectRegisteredTools(minimal) {
     const opts = { minimal };
     const stub = server;
     registerFoundationCore(stub, opts);
-    if (shouldExpose("doctor", minimal)) {
-        tools.push(DOCTOR_TOOL_FOR_BUDGET);
-    }
     registerSpec(stub, opts);
     registerCompass(stub, opts);
     registerTools(stub, opts);

package/dist/modules/foundation/dialects/agentsmd.js

@@ -0,0 +1,95 @@
+import { commonPrefix, delimit, } from "./types.js";
+const NESTED_THRESHOLD = 3;
+function degradeSection(title, laws) {
+    const lines = [`## ${title}`, ""];
+    for (const law of laws) {
+        const globHint = law.scope.length > 0 ? `In files that match \`${law.scope.join("`, `")}\`, ` : "";
+        lines.push(`### ${law.title} (\`${law.id}\`)`);
+        lines.push("");
+        lines.push(`${globHint}${law.prose}`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * AGENTS.md dialect: move scope into prose; optional nested AGENTS.md files.
+ * Emits patch-delimited content for the root file.
+ */
+export const agentsmdDialect = {
+    id: "agentsmd",
+    compile(laws, ctx) {
+        const active = laws.filter((l) => (l.status ?? "active") !== "draft");
+        const global = active.filter((l) => l.scope.length === 0);
+        const scoped = active.filter((l) => l.scope.length > 0);
+        const byPrefix = new Map();
+        for (const law of scoped) {
+            const pref = commonPrefix(law.scope) || "_misc";
+            const list = byPrefix.get(pref) ?? [];
+            list.push(law);
+            byPrefix.set(pref, list);
+        }
+        const artifacts = [];
+        const rootParts = [
+            "## speclaw laws (generated)",
+            "",
+            "_Edit `docs/standards/*.md` or `.speclaw/laws-manifest.json`; do not edit this block._",
+            "",
+        ];
+        if (global.length)
+            rootParts.push(degradeSection("Global rules", global));
+        const nestedMention = [];
+        for (const [pref, group] of [...byPrefix.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+            const pkg = pref !== "_misc" && pref.length > 0;
+            const nest = pkg &&
+                group.length >= NESTED_THRESHOLD &&
+                // Nested only when a package.json exists under that prefix.
+                true;
+            // Nesting is decided by the orchestrator (fs check); here we always
+            // put dense prefixes in a nested artifact path hint via mode write.
+            if (nest && pref !== "_misc") {
+                nestedMention.push(pref);
+                artifacts.push({
+                    path: `${pref}/AGENTS.md`,
+                    contents: delimit("laws", degradeSection(`Rules for \`${pref}\``, group) +
+                        `\n_Generated by speclaw from law ids: ${group.map((l) => l.id).join(", ")}_\n`),
+                    lawIds: group.map((l) => l.id),
+                    mode: "write",
+                });
+            }
+            else {
+                const title = pref === "_misc" ? "Scoped rules" : `Rules for \`${pref}\``;
+                rootParts.push(degradeSection(title, group));
+            }
+        }
+        if (nestedMention.length) {
+            rootParts.push("## Nested AGENTS.md files", "");
+            for (const p of nestedMention)
+                rootParts.push(`- [\`${p}/AGENTS.md\`](${p}/AGENTS.md)`);
+            rootParts.push("");
+        }
+        void ctx;
+        artifacts.push({
+            path: "AGENTS.md",
+            contents: rootParts.join("\n"),
+            lawIds: active.map((l) => l.id),
+            mode: "patch-delimited",
+            marker: "laws",
+        });
+        artifacts.push({
+            path: "CLAUDE.md",
+            contents: [
+                "## speclaw (generated)",
+                "",
+                "Import shared agent context: `@AGENTS.md`",
+                "",
+                "Path-scoped laws live under `.claude/rules/` (symlink to `ai-specs/rules`).",
+                "Do not rely on Claude Code reading `AGENTS.md` without the import.",
+                "",
+            ].join("\n"),
+            lawIds: active.map((l) => l.id),
+            mode: "patch-delimited",
+            marker: "laws",
+        });
+        return artifacts;
+    },
+};