agentplugged 1.4.0 → 2.0.0

package/dist/project-command.js

@@ -1,886 +1,158 @@
-import { Fo as issueName, ts as ErrorCode } from "./dist.js";
-// ../../packages/core/dist/init/layout.js
-/** Folder holding the method inside the product's repository. */
-const METHOD_DIR = ".agentplugged";
-const METHOD_CONFIG_PATH = `${METHOD_DIR}/method.yaml`;
-const METHOD_GITIGNORE_PATH = `${METHOD_DIR}/.gitignore`;
-/** Copy of the shipped model table, generated by `init`; the creator's values go in `method.yaml`. */
-const MODELS_PATH = `${METHOD_DIR}/models.yaml`;
-const METHOD_CONSTITUTION_PATH = `${METHOD_DIR}/AGENTS.md`;
-const ROOT_CONSTITUTION_PATH = "AGENTS.md";
+import { Vs as ErrorCode } from "./hash.js";
+import { B as AgentPluggedError, C as nameWords, F as PROFILE_PATH, I as acceptanceText, L as parseKept, P as ACCEPTANCE_PLACES, R as renderProfile, _ as findBricks, d as bricksOfMap, r as loadCodeMap, v as matchingSources, x as stem, y as searchWords, z as withSource } from "./map-cache.js";
+// ../../packages/core/dist/project-profile/repo-map.js
 /**
-* The detail of the constitution, generated, read on demand (corrections B; one file
-* per section): the `AGENTS.md` that the tools load at every request stays short.
+* The map of a repository for one piece of work: the files that matter for a request, each with the
+* symbols it exports (functions, classes, types) and their signatures, within a budget of tokens.
+* It replaces the wide reads an agent makes to find its way. Pure and deterministic: the same
+* bricks and the same request always give the same text, and the text never exceeds the budget.
+*
+* Files are ranked the way a reader would: the files the request names come first, then those whose
+* path or symbols carry its words (a word that is everywhere weighs little), and the files the rest
+* of the code leans on break ties and fill what is left.
 */
-const REFERENCE_DIR = `${METHOD_DIR}/reference`;
-/** The single file the reference was: `sync` removes it when it generated it. */
-const REFERENCE_LEGACY_PATH = `${METHOD_DIR}/REFERENCE.md`;
-/** The file of one section of the reference, by its short name (`reporting`, `tool-story`…). */
-const referenceFilePath = (name) => `${REFERENCE_DIR}/${name}.md`;
-/** Sub-folders of `.agentplugged/`, each kept in Git by a `.gitkeep`. */
-const METHOD_SUBDIRS = [
-	"agents",
-	"skills",
-	"docs",
-	"epics",
-	"stories",
-	"salle",
-	"memory",
-	"overrides",
-	".cache"
-];
-/** Tool instruction files that may belong to the creator; `init` never creates them. */
-const POINTER_FILES = ["CLAUDE.md", "GEMINI.md"];
-// ../../packages/core/dist/errors.js
-/** Expected, translatable failure: `{ code, message_key, details }`. */
-var AgentPluggedError = class extends Error {
-	code;
-	message_key;
-	details;
-	/**
-	* What the engine adds when it answers an agent (the gesture to make, how many times the same
-	* refusal came): sent with the details, never part of them, so that the cause of the refusal and
-	* the advice stay apart.
-	*/
-	advice;
-	constructor(code, messageKey, details = {}, advice = {}) {
-		super(`${code}: ${messageKey}`);
-		this.name = "AgentPluggedError";
-		this.code = code;
-		this.message_key = messageKey;
-		this.details = details;
-		this.advice = advice;
-	}
-	toPayload() {
-		return {
-			code: this.code,
-			message_key: this.message_key,
-			details: {
-				...this.details,
-				...this.advice
-			}
-		};
-	}
-};
-/**
-* `details` of a field error: the English `reason`, plus `reason_key` (a message key surfaces
-* translate) when the reason is a known schema message, or when `reasonKey` is given.
-*/
-function reasonDetails(reason, reasonKey, params = {}) {
-	const known = issueName(reason);
-	const key = reasonKey ?? (known === void 0 ? void 0 : `reason.${known}`);
-	return key === void 0 ? {
-		reason,
-		...params
-	} : {
-		reason,
-		reason_key: key,
-		...params
-	};
-}
-/** `UNEXPECTED`, with the reason it states. */
-function unexpected(reason) {
-	return new AgentPluggedError(ErrorCode.UNEXPECTED, "error.unexpected", { reason });
-}
-/** `UNEXPECTED`: `what` (a port the caller did not give) is not available here. */
-function unavailable(what) {
-	return unexpected(`${what} is not available here`);
-}
-// ../../packages/core/dist/reuse/tokens.js
-/**
-* The words of a source file, for any language. No parser: a scanner
-* by regular expressions that every C-like or scripting language fits. Comments and blanks are
-* dropped; identifiers become one word, numbers one word, strings one word, and the keywords (the
-* union of the common languages') are kept: two functions that only differ by their names and
-* values read the same. Statements made only of references to other files (imports) are dropped:
-* many files import the same things, which is not a duplicate. Pure: text in, words out.
-*/
-/** The interned words of a run: one number per distinct normalised word. */
-var WordTable = class {
-	#ids = /* @__PURE__ */ new Map();
-	intern(word) {
-		const known = this.#ids.get(word);
-		if (known !== void 0) return known;
-		const id = this.#ids.size + 1;
-		this.#ids.set(word, id);
-		return id;
-	}
-};
-const HASH = /* @__PURE__ */ new Set([
-	"py",
-	"rb",
-	"sh",
-	"bash",
-	"zsh",
-	"ps1",
-	"pl",
-	"pm",
-	"r",
-	"ex",
-	"exs",
-	"nim",
-	"cr",
-	"yml",
-	"yaml",
-	"toml"
-]);
-const DASH = /* @__PURE__ */ new Set([
-	"sql",
-	"lua",
-	"hs",
-	"elm",
-	"ada"
-]);
-const SLASH_HASH = /* @__PURE__ */ new Set([
-	"php",
-	"pl",
-	"pm"
-]);
-function styleOf(path) {
-	const extension = path.toLowerCase().split(".").at(-1) ?? "";
-	if (SLASH_HASH.has(extension)) return "slashhash";
-	if (HASH.has(extension)) return "hash";
-	return DASH.has(extension) ? "dash" : "slash";
-}
-/** The words of a text, as a set: lists of names written once, space-separated. */
-function wordSet(text) {
-	return new Set(text.split(/\s+/).filter((word) => word !== ""));
-}
-const KEYWORDS = wordSet(`if else elif elsif unless for foreach while do until loop switch case default match when where
-  break continue return yield await async function def fn func fun class struct enum interface trait
-  impl type typedef let const var val mut static final abstract public private protected internal
-  override virtual readonly try catch except finally rescue ensure throw throws raise new delete
-  null nil none true false undefined this self super in of is as and or not with lambda pass defer
-  go chan select range import from export package use using module namespace extends implements
-  instanceof typeof void goto then begin end`);
-/** Words that open a statement made only of references to other files. */
-const IMPORTS = /* @__PURE__ */ new Set([
-	"import",
-	"from",
-	"using",
-	"package",
-	"use",
-	"require",
-	"require_relative"
-]);
-const PREPROCESSOR = /* @__PURE__ */ new Set([
-	"include",
-	"pragma",
-	"import",
-	"ifndef",
-	"ifdef",
-	"endif"
-]);
-const OPERATORS = ">>>=|<<=|>>=|\\*\\*=|\\.\\.\\.|===|!==|=>|->|::|&&|\\|\\||\\?\\?|\\?\\.|==|!=|<=|>=|\\+\\+|--|\\+=|-=|\\*=|/=|%=|&=|\\|=|\\^=|<<|>>|\\*\\*|\\.\\.";
-function scannerOf(style) {
-	return [
-		"(\\s+)",
-		`(${style === "slash" ? "//[^\\n]*|/\\*[\\s\\S]*?(?:\\*/|$)" : style === "slashhash" ? "//[^\\n]*|#[^\\n]*|/\\*[\\s\\S]*?(?:\\*/|$)" : style === "hash" ? "(?<![${])#[^\\n]*" : "--\\[\\[[\\s\\S]*?(?:\\]\\]|$)|--[^\\n]*|/\\*[\\s\\S]*?(?:\\*/|$)"})`,
-		"(\"\"\"[\\s\\S]*?(?:\"\"\"|$)|'''[\\s\\S]*?(?:'''|$))",
-		"(\"(?:\\\\.|[^\"\\\\\\n])*\"?|'(?:\\\\.|[^'\\\\\\n])*'?|`(?:\\\\[\\s\\S]|[^`\\\\])*`?)",
-		"([\\p{L}_$][\\p{L}\\p{N}_$]*)",
-		"(\\d[\\w.]*)",
-		`(${OPERATORS}|[\\s\\S])`
-	].join("|");
-}
-const SCANNERS = {
-	slash: scannerOf("slash"),
-	slashhash: scannerOf("slashhash"),
-	hash: scannerOf("hash"),
-	dash: scannerOf("dash")
-};
-function countLines(chunk) {
-	let count = 0;
-	for (let i = chunk.indexOf("\n"); i !== -1; i = chunk.indexOf("\n", i + 1)) count += 1;
-	return count;
-}
-function scan(text, style) {
-	const scanner = new RegExp(SCANNERS[style], "uy");
-	const raws = [];
-	let line = 1;
-	let first = true;
-	let position = 0;
-	while (position < text.length) {
-		scanner.lastIndex = position;
-		const match = scanner.exec(text);
-		if (match === null || match[0] === "") {
-			position += 1;
-			continue;
-		}
-		const from = position;
-		position = scanner.lastIndex;
-		const [chunk, blank, comment, , , word, number, mark] = match;
-		const startLine = line;
-		line += countLines(chunk);
-		if (blank !== void 0) {
-			if (countLines(blank) > 0) first = true;
-			continue;
+/** Tokens the map takes by default, and the most a caller may ask. */
+const MAP_TOKENS = 1500;
+const MAP_MAX_TOKENS = 3e3;
+/** Characters per token assumed: low on purpose, code is dense, so the real count stays under. */
+const CHARS_PER_TOKEN = 3;
+/** Most symbols of one file, and of a file chosen only for its place in the code. */
+const SYMBOLS_PER_FILE = 10;
+const SYMBOLS_PER_FILLER = 3;
+/** The share of the budget the files unrelated to the request may take. */
+const FILLER_SHARE = .25;
+/** The words of a request read at most. */
+const REQUEST_CHARS = 8e3;
+const REQUEST_WORDS = 300;
+/** The tokens a text takes, estimated (never fewer than the real count for code). */
+function mapTokens(text) {
+	return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+const HEADER = "Repo map (files by relevance; line: exported declaration)";
+/** The words of a request: its identifiers split, folded to roots, each once. */
+function requestStems(request) {
+	const words = request.slice(0, REQUEST_CHARS).match(/[A-Za-z][A-Za-z0-9_$]{2,}/g) ?? [];
+	return [...new Set(searchWords(words.slice(0, REQUEST_WORDS * 4)))].slice(0, REQUEST_WORDS);
+}
+function candidatesOf(bricks, request) {
+	const byFile = /* @__PURE__ */ new Map();
+	for (const brick of bricks) {
+		if (!brick.exported) continue;
+		const list = byFile.get(brick.path);
+		if (list === void 0) byFile.set(brick.path, [brick]);
+		else list.push(brick);
+	}
+	const wanted = requestStems(request);
+	const stems = /* @__PURE__ */ new Map();
+	const spread = /* @__PURE__ */ new Map();
+	for (const [path, list] of byFile) {
+		const inPath = new Set(nameWords(path).map(stem));
+		const names = /* @__PURE__ */ new Map();
+		const all = new Set(inPath);
+		for (const brick of list) {
+			const own = new Set(nameWords(brick.name).map(stem));
+			names.set(brick, own);
+			for (const word of own) all.add(word);
 		}
-		if (comment !== void 0) continue;
-		const kind = word !== void 0 ? "word" : mark !== void 0 ? "mark" : number !== void 0 ? "number" : "string";
-		raws.push({
-			kind,
-			text: word ?? mark ?? "",
-			line: startLine,
-			first,
-			start: from,
-			end: position
+		stems.set(path, {
+			path: inPath,
+			names
 		});
-		first = false;
-	}
-	return raws;
-}
-const OPENING = /* @__PURE__ */ new Set([
-	"(",
-	"[",
-	"{"
-]);
-const CLOSING = /* @__PURE__ */ new Set([
-	")",
-	"]",
-	"}"
-]);
-/**
-* The indexes of the raw words that belong to a statement of references (`import x from "y"`,
-* `use a::{b, c};`, `#include <x>`, `from a import (b,\n c)`): from its first word to the end of its
-* line, or of its brackets.
-*/
-function referenceWords(raws) {
-	const skipped = /* @__PURE__ */ new Set();
-	for (let i = 0; i < raws.length; i += 1) {
-		const raw = raws[i];
-		if (!raw.first || skipped.has(i)) continue;
-		const next = raws[i + 1];
-		let reference = false;
-		if (raw.kind === "word" && IMPORTS.has(raw.text)) reference = !(raw.text === "using" && next?.text === "(");
-		else if (raw.kind === "word" && raw.text === "export") reference = next?.text === "*" || next?.text === "{";
-		else if (raw.kind === "mark" && raw.text === "#" && next?.kind === "word") reference = PREPROCESSOR.has(next.text);
-		if (!reference) continue;
-		let depth = 0;
-		let j = i;
-		for (; j < raws.length; j += 1) {
-			const current = raws[j];
-			if (j > i && current.line !== raws[j - 1].line && depth <= 0) break;
-			skipped.add(j);
-			if (OPENING.has(current.text)) depth += 1;
-			else if (CLOSING.has(current.text)) depth -= 1;
-			else if (current.text === ";" && depth <= 0) {
-				j += 1;
-				break;
+		for (const word of all) spread.set(word, (spread.get(word) ?? 0) + 1);
+	}
+	const total = Math.max(1, byFile.size);
+	const weight = (word) => Math.log(1 + total / (spread.get(word) ?? total));
+	const out = [];
+	const sameName = /* @__PURE__ */ new Map();
+	for (const path of byFile.keys()) {
+		const name = path.split("/").at(-1) ?? path;
+		sameName.set(name, (sameName.get(name) ?? 0) + 1);
+	}
+	for (const [path, list] of byFile) {
+		const known = stems.get(path);
+		let relevance = 0;
+		const matched = /* @__PURE__ */ new Map();
+		for (const word of wanted) {
+			if (known.path.has(word)) relevance += 2 * weight(word);
+			let named = false;
+			for (const [brick, own] of known.names) {
+				if (!own.has(word)) continue;
+				named = true;
+				matched.set(brick, (matched.get(brick) ?? 0) + weight(word));
 			}
+			if (named) relevance += 3 * weight(word);
 		}
-		i = j - 1;
-	}
-	return skipped;
-}
-/**
-* The words of a file as they stand, comments left out, with their lines and offsets: what the
-* mutations need to change a comparison, a constant or a return without touching a
-* string or a comment. `path` tells the comment style.
-*/
-function sourceWords(path, text) {
-	return scan(text, styleOf(path));
-}
-/** The normalised words of a file, with their lines. `path` tells the comment style. */
-function wordsOf(path, text, table) {
-	const raws = scan(text, styleOf(path));
-	const skipped = referenceWords(raws);
-	const ids = [];
-	const lines = [];
-	raws.forEach((raw, index) => {
-		if (skipped.has(index)) return;
-		let word;
-		if (raw.kind === "word") word = KEYWORDS.has(raw.text) ? raw.text : "
id";
-		else if (raw.kind === "number") word = "
num";
-		else if (raw.kind === "string") word = "
str";
-		else word = raw.text;
-		ids.push(table.intern(word));
-		lines.push(raw.line);
-	});
-	return {
-		ids: Uint32Array.from(ids),
-		lines: Uint32Array.from(lines)
-	};
-}
-// ../../packages/core/dist/reuse/code-files.js
-/**
-* Which files of a repository the duplicate detector reads: the source
-* code a person wrote and maintains. Tests (repetitive by nature), generated code, lockfiles,
-* minified bundles, binaries, documents and the folders every tool ignores are left out, whatever
-* the language.
-*/
-const CODE_EXTENSION = wordSet(`js jsx mjs cjs ts tsx mts cts vue svelte astro py pyi rb go rs java kt kts scala groovy swift m mm
-  c h cc cpp cxx hpp hh cs php dart lua pl pm r ex exs hs nim zig cr sh bash zsh ps1 sql`);
-const IGNORED_FOLDER = /* @__PURE__ */ new Set([
-	"node_modules",
-	"dist",
-	"build",
-	"out",
-	"target",
-	"vendor",
-	"third_party",
-	"thirdparty",
-	".git",
-	".next",
-	".nuxt",
-	".svelte-kit",
-	".turbo",
-	".cache",
-	".method",
-	".agentplugged",
-	"coverage",
-	"bin",
-	"obj",
-	"__pycache__",
-	".venv",
-	"venv",
-	"env",
-	"site-packages",
-	"generated",
-	"__generated__",
-	"migrations"
-]);
-const TEST_FILE = /(?:\.(?:test|spec|e2e|cy|stories)\.|_test\.|_spec\.|(?:^|\/)test_[^/]*\.py$|(?:^|\/)(?:tests?|__tests__|__mocks__|__snapshots__|spec|specs|e2e|fixtures?|testdata|testing)\/)/i;
-/**
-* Helpers that only tests use: `__helpers__/`, `pair.test-support.ts`, a `*-testkit/` folder. They
-* repeat the code they stand in for by design, like the tests.
-*/
-const TEST_SUPPORT = /(?:\.test-(?:support|utils|helpers)\.|(?:^|\/)(?:__helpers__|(?:[\w.]+-)?testkit)\/)/i;
-/** A folder starting with a dot (`.claude`, `.github`, `.husky`) holds tools and settings, not the product. */
-const isHidden = (folder) => folder.length > 1 && folder.startsWith(".") && folder !== "..";
-/** `OrderServiceTest.java`, `CartSpec.scala`: a capitalised suffix after a word (`Latest.java` is not one). */
-const TEST_CLASS = /[a-z0-9](?:Test|Tests|Spec)\.(?:java|kt|cs|scala|swift|php)$/;
-const GENERATED_FILE = /(?:\.min\.|\.bundle\.|\.generated\.|\.gen\.|\.g\.(?:cs|dart)$|\.designer\.cs$|\.pb\.go$|_pb2(?:_grpc)?\.py$|_pb\.(?:js|ts)$|\.d\.ts$|\.snap$)/i;
-/** The largest file read (bytes): beyond, it is a bundle or a data dump, not code a person keeps. */
-const MAX_FILE_BYTES = 2e5;
-/** True when the detector reads the file: source code, not a test, not generated, not ignored. */
-function isCodePath(path) {
-	const p = path.replaceAll("\\", "/");
-	const parts = p.split("/");
-	const name = parts.at(-1) ?? "";
-	const extension = name.includes(".") ? (name.split(".").at(-1) ?? "").toLowerCase() : "";
-	if (!CODE_EXTENSION.has(extension)) return false;
-	if (parts.slice(0, -1).some((folder) => IGNORED_FOLDER.has(folder.toLowerCase()) || isHidden(folder))) return false;
-	return !TEST_FILE.test(p) && !TEST_SUPPORT.test(p) && !TEST_CLASS.test(name) && !GENERATED_FILE.test(name);
-}
-/**
-* True when a file's text is not code to compare: a binary (a NUL), or minified (very long lines).
-*/
-function isReadableCode(text) {
-	if (text.length === 0 || text.length > 2e5 || text.includes("\0")) return false;
-	const lines = text.split("\n").length;
-	return text.length / lines <= 300;
-}
-const TEST_NAME = /(?:\.(?:tests?|specs?|e2e|cy)\.[a-z0-9]+$|[_-](?:test|spec)\.[a-z0-9]+$|(?:^|\/)test_[^/]*\.py$)/i;
-/** `OrderServiceTest.java`, `CartSpec.scala`: a capitalised suffix after a word; `Spec` only where it is a test style. */
-const TEST_CLASS_NAME = /[a-z0-9](?:Tests?\.(?:java|kt|cs|scala|swift|php|groovy)|Spec\.(?:scala|groovy|kt))$/;
-const TEST_FOLDER = /(?:^|\/)(?:tests?|__tests__|spec|specs|e2e)\//i;
-/** Folders that hold what others wrote or a tool made: no test of the product lives there. */
-const NOT_THE_PRODUCT = /* @__PURE__ */ new Set([
-	"node_modules",
-	"dist",
-	"vendor",
-	"third_party",
-	"thirdparty",
-	".git",
-	"coverage",
-	"site-packages",
-	"__pycache__",
-	".venv",
-	"venv",
-	".next",
-	".nuxt",
-	".svelte-kit",
-	".turbo",
-	".cache",
-	".agentplugged"
-]);
-/**
-* True when the path is a file of tests in a language (the guard before a write): named
-* as one (`a.test.ts`, `a_test.go`, `test_a.py`, `ATest.java`) or, when `folders` is set, inside a
-* folder of tests (`tests/`, `__tests__/`, `spec/`, `e2e/`). `path` is relative to the product:
-* the folders above it say nothing. Generated files, snapshots and what others wrote are no test files.
-*/
-function isTestPath(path, folders) {
-	const p = path.replaceAll("\\", "/");
-	const parts = p.split("/");
-	const name = parts.at(-1) ?? "";
-	const extension = name.includes(".") ? (name.split(".").at(-1) ?? "").toLowerCase() : "";
-	if (!CODE_EXTENSION.has(extension) || GENERATED_FILE.test(name)) return false;
-	if (parts.slice(0, -1).some((folder) => NOT_THE_PRODUCT.has(folder.toLowerCase()))) return false;
-	return TEST_NAME.test(p) || TEST_CLASS_NAME.test(name) || folders && TEST_FOLDER.test(p);
-}
-// ../../packages/core/dist/reuse/twins.js
-const MODIFIERS = "(?:(?:public|private|protected|internal|static|final|abstract|virtual|override|open|async|suspend|inline|operator|sealed|synchronized|export|default|pub(?:\\([^)]*\\))?|unsafe)\\s+)";
-const PATTERNS = [
-	new RegExp(`^\\s*${MODIFIERS}*function\\s*\\*?\\s*([A-Za-z_$][\\w$]*)\\s*(?:<[^>(]*>)?\\s*\\(([^)]*)\\)`),
-	/^\s*(?:async\s+)?def\s+(?:self\.)?([A-Za-z_]\w*[?!]?)\s*(?:\(([^)]*)\))?/,
-	/^\s*func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)\s*(?:\[[^\]]*\])?\s*\(([^)]*)\)/,
-	new RegExp(`^\\s*${MODIFIERS}*(?:fn|fun)\\s+(?:<[^>]*>\\s*)?([A-Za-z_]\\w*)\\s*(?:<[^>(]*>)?\\s*\\(([^)]*)\\)`),
-	/^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::[^=]+)?=\s*(?:async\s+)?(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s*(?::[^=]+)?=>/,
-	new RegExp(`^\\s*${MODIFIERS}+[\\w<>\\[\\],.?*&:\\s]+?\\s+([A-Za-z_]\\w*)\\s*\\(([^)]*)\\)\\s*(?:throws [\\w, .]+)?\\s*(?:\\{|=>|$)`),
-	/^\s{2,}(?:static\s+)?(?:async\s+)?(?:get\s+|set\s+)?([A-Za-z_$][\w$]*)\s*\(([^)]*)\)\s*(?::\s*[^{=]+)?\{\s*$/
-];
-/** Names that say nothing about what a function does. */
-const GENERIC = wordSet(`constructor main run init setup start stop test render handle handler get set add remove update
-  delete create build parse format validate check apply call exec execute map filter reduce toString
-  equals hashCode compare close open read write load save new default index each next`);
-const NOT_A_FUNCTION = /* @__PURE__ */ new Set([
-	"if",
-	"for",
-	"while",
-	"switch",
-	"catch",
-	"return",
-	"function",
-	"else"
-]);
-/** The functions a file declares, one per declaration line. */
-function functionsOf(path, text) {
-	const found = [];
-	const lines = text.split("\n");
-	for (let index = 0; index < lines.length; index += 1) {
-		const line = lines[index];
-		if (line.length > 400) continue;
-		for (const pattern of PATTERNS) {
-			const match = pattern.exec(line);
-			const name = match?.[1];
-			if (match === null || name === void 0 || NOT_A_FUNCTION.has(name)) continue;
-			const raw = match[2] ?? match[3] ?? "";
-			found.push({
-				name,
-				params: paramsOf(raw, path),
-				path,
-				line: index + 1,
-				nested: /^\s/.test(line)
-			});
-			break;
-		}
-	}
-	return found;
-}
-const PARAM_MODIFIERS = /* @__PURE__ */ new Set([
-	"final",
-	"const",
-	"mut",
-	"ref",
-	"val",
-	"var",
-	"readonly",
-	"in",
-	"out"
-]);
-/**
-* The names of the parameters, not their types: `name: Type` and Go's `name Type` give the first
-* word, `Type name` (Java, C, C#) the last.
-*/
-function paramsOf(raw, path) {
-	const nameFirst = /\.go$/i.test(path);
-	return raw.split(",").map((part) => {
-		const bare = part.split("=")[0] ?? "";
-		const words = ((bare.split(":")[0] ?? "").match(/[A-Za-z_$][\w$]*/g) ?? []).filter((word) => !PARAM_MODIFIERS.has(word));
-		return bare.includes(":") || nameFirst ? words[0] : words.at(-1);
-	}).filter((name) => name !== void 0 && name !== "self" && name !== "this");
-}
-/** A name in lower-case words: `getUserById` and `get_user_by_id` are the same. */
-function nameWords(name) {
-	return name.replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/[^a-z\d]+/).filter((word) => word !== "");
-}
-function distance(a, b) {
-	if (a === b) return 0;
-	let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
-	for (let i = 1; i <= a.length; i += 1) {
-		const row = [i];
-		for (let j = 1; j <= b.length; j += 1) row[j] = Math.min(previous[j] + 1, row[j - 1] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
-		previous = row;
-	}
-	return previous[b.length];
-}
-/** Closeness (0 to 1) of two names, once split into words. */
-function nameLikeness(a, b) {
-	const left = nameWords(a).join(" ");
-	const right = nameWords(b).join(" ");
-	const longest = Math.max(left.length, right.length);
-	return longest === 0 ? 0 : 1 - distance(left, right) / longest;
-}
-/** Closeness of the parameters: shared names over the names of the longer list. */
-function paramsLikeness(a, b) {
-	const longest = Math.max(a.length, b.length);
-	if (longest === 0) return 0;
-	const names = new Set(b.map((name) => nameWords(name).join(" ")));
-	return a.filter((name) => names.has(nameWords(name).join(" "))).length / longest;
-}
-/** Languages whose functions all live inside a class: an indented declaration is then the norm. */
-const CLASS_ONLY = /\.(?:java|kt|kts|scala|groovy|cs|php|swift|dart)$/i;
-/**
-* Two methods (or inner functions) of the same name in different files are the two sides of an
-* interface, a port and its adapter: not a function written twice. Only a declaration other files
-* could import counts, on one side at least.
-*/
-function bothInside(a, b) {
-	return a.nested && b.nested && !CLASS_ONLY.test(a.path) && !CLASS_ONLY.test(b.path);
-}
-function meaningful(name) {
-	const words = nameWords(name);
-	return !GENERIC.has(name) && (words.length >= 2 || name.length >= 8);
-}
-/**
-* The functions of `added` (declared on a line the change added) that look like a function of the
-* repository: the same name in words, or a close name with close parameters. Never the function
-* itself; generic names (`get`, `run`, `handle`) and short ones say nothing and are left out.
-*/
-function findTwins(files, added) {
-	const all = files.flatMap((file) => functionsOf(file.path, file.text));
-	const fresh = all.filter((fn) => added.get(fn.path)?.has(fn.line) === true && meaningful(fn.name));
-	if (fresh.length === 0) return [];
-	const byWord = /* @__PURE__ */ new Map();
-	for (const fn of all) {
-		if (!meaningful(fn.name)) continue;
-		for (const word of new Set(nameWords(fn.name))) {
-			if (word.length < 3) continue;
-			const list = byWord.get(word);
-			if (list === void 0) byWord.set(word, [fn]);
-			else if (list.length < 300) list.push(fn);
-		}
-	}
-	const twins = [];
-	for (const fn of fresh) {
-		const candidates = /* @__PURE__ */ new Set();
-		for (const word of nameWords(fn.name)) for (const other of byWord.get(word) ?? []) candidates.add(other);
-		let best;
-		for (const other of candidates) {
-			if (other.path === fn.path && other.line === fn.line) continue;
-			if (bothInside(fn, other)) continue;
-			if (added.get(other.path)?.has(other.line) === true && (other.path < fn.path || other.path === fn.path && other.line < fn.line)) continue;
-			const likeness = nameLikeness(fn.name, other.name);
-			const same = nameWords(fn.name).join(" ") === nameWords(other.name).join(" ");
-			let why;
-			if (same) why = "same_name";
-			else if (likeness >= .8 && paramsLikeness(fn.params, other.params) >= .5) why = "close_name";
-			if (why === void 0) continue;
-			const score = (same ? 2 : 1) + likeness;
-			if (best === void 0 || score > best.score) best = {
-				fn: other,
-				why,
-				score
-			};
-		}
-		if (best !== void 0) twins.push({
-			name: fn.name,
-			path: fn.path,
-			line: fn.line,
-			twin: {
-				name: best.fn.name,
-				path: best.fn.path,
-				line: best.fn.line
-			},
-			why: best.why
-		});
-	}
-	return twins.sort((a, b) => a.path.localeCompare(b.path) || a.line - b.line).slice(0, 10);
-}
-// ../../packages/core/dist/project-profile/bricks.js
-/** Most bricks kept: past it the registry is cut, never a failure. */
-const MAX_BRICKS = 2e4;
-const SIG_MAX = 100;
-const TYPE_PATTERN = /^\s*(?:(?:export|default|public|private|protected|internal|pub(?:\([^)]*\))?|abstract|final|sealed|static|data|open|partial|declare)\s+)*(class|interface|struct|enum|trait|type|record|protocol|object|union)\s+([A-Za-z_$][\w$]*)/;
-/** Names a person would not search for (the same ones the twin detector ignores as generic). */
-const SKIP_NAME = /* @__PURE__ */ new Set([
-	"constructor",
-	"main",
-	"default",
-	"index"
-]);
-/**
-* A function whose parameter list runs over several lines: the declaration line opens the
-* parenthesis and does not close it (`function f(`, `def f(`, `const f = async (`).
-*/
-const OPEN_DECLARATION = /^(?:export\s+)?(?:default\s+)?(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?(?:(?:function\s*\*?|def|func|fn|fun)\s+([A-Za-z_$][\w$]*)|(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::[^=]+)?=\s*(?:async\s+)?)\s*(?:<[^>(]*>)?\s*\(([^)]*)$/;
-/** The names of the parameters listed on the lines after an opened parenthesis. */
-function multilineParams(first, lines, from) {
-	let raw = first;
-	for (let next = from; next < Math.min(lines.length, from + 14); next += 1) {
-		const line = lines[next];
-		const close = line.indexOf(")");
-		if (close !== -1) {
-			raw += ` ${line.slice(0, close)}`;
-			break;
-		}
-		raw += ` ${line}`;
-	}
-	return splitTopLevel(raw).map((part) => /[A-Za-z_$][\w$]*/.exec((part.split(":")[0] ?? "").trim())?.[0]).filter((name) => name !== void 0 && name !== "readonly");
-}
-/** The parts of a list split at the commas that are not inside <>, () or []. */
-function splitTopLevel(text) {
-	const parts = [];
-	let depth = 0;
-	let current = "";
-	for (const char of text) {
-		if ("<([{".includes(char)) depth += 1;
-		else if (">)]}".includes(char)) depth = Math.max(0, depth - 1);
-		if (char === "," && depth === 0) {
-			parts.push(current);
-			current = "";
-		} else current += char;
-	}
-	parts.push(current);
-	return parts;
-}
-/** The bricks of one file: the functions other files could import, and the types. */
-function bricksOf(path, text) {
-	const found = [];
-	const seen = /* @__PURE__ */ new Set();
-	const lines = text.split("\n");
-	for (const fn of functionsOf(path, text)) {
-		if (fn.nested || SKIP_NAME.has(fn.name)) continue;
-		seen.add(`${fn.line}`);
-		found.push({
-			name: fn.name,
-			kind: "fn",
-			path,
-			line: fn.line,
-			sig: `${fn.name}(${fn.params.join(", ")})`.slice(0, SIG_MAX)
-		});
-	}
-	for (let index = 0; index < lines.length; index += 1) {
-		const line = lines[index];
-		if (line.length > 300 || seen.has(`${index + 1}`)) continue;
-		const open = OPEN_DECLARATION.exec(line);
-		const opened = open?.[1] ?? open?.[2];
-		if (open === null || opened === void 0 || SKIP_NAME.has(opened)) continue;
-		found.push({
-			name: opened,
-			kind: "fn",
-			path,
-			line: index + 1,
-			sig: `${opened}(${multilineParams(open[3] ?? "", lines, index + 1).join(", ")})`.slice(0, SIG_MAX)
-		});
-	}
-	found.sort((a, b) => a.line - b.line);
-	for (let index = 0; index < lines.length; index += 1) {
-		const line = lines[index];
-		if (line.length > 300) continue;
-		const match = TYPE_PATTERN.exec(line);
-		const name = match?.[2];
-		if (match === null || name === void 0 || name.length < 3) continue;
-		if (/^\s*[,}]/.test(line.slice(match[0].length))) continue;
-		if (match[1] === "type" && (/^\s/.test(line) || !/^(?:export\s+)?type\s+[A-Z]/.test(line)) && !(/\.go$/.test(path) && !/^\s/.test(line))) continue;
-		found.push({
-			name,
-			kind: "type",
+		const base = path.split("/").at(-1) ?? path;
+		const mentioned = request.includes(path) ? 12 : base.length >= 6 && sameName.get(base) === 1 && request.includes(base) ? 6 : 0;
+		const leaned = list.reduce((sum, brick) => sum + brick.refs, 0);
+		out.push({
 			path,
-			line: index + 1,
-			sig: line.trim().replace(/\s*[{(=].*$/, "").slice(0, SIG_MAX)
+			bricks: list,
+			relevance,
+			mentioned,
+			centrality: Math.log(1 + leaned),
+			matched
 		});
 	}
-	return found;
-}
-/** The registry of a set of files (tests, generated code and the like are left out). */
-function buildBricks(files) {
-	const all = [];
-	for (const file of files) {
-		if (!isCodePath(file.path) || !isReadableCode(file.text)) continue;
-		all.push(...bricksOf(file.path, file.text));
-		if (all.length >= 2e4) break;
-	}
-	return all.slice(0, MAX_BRICKS);
-}
-/** Largest file read to build the registry (bytes). */
-const BRICK_FILE_BYTES = MAX_FILE_BYTES;
-/** Lower-case search words of a request: names are split, plurals folded, filler dropped. */
-function searchWords(words) {
-	const filler = new Set("the a an of for to and or in is it does do into from with that this all any how we there already exist exists".split(" "));
-	const out = /* @__PURE__ */ new Set();
-	for (const word of words.flatMap((entry) => nameWords(entry))) {
-		if (word.length < 2 || filler.has(word)) continue;
-		out.add(stem(word));
-	}
-	return [...out];
-}
-/**
-* A word folded to its root, so that « parsing dates » finds `parseDate`: plural, `-ing`, `-ed`, a
-* final `e` and a doubled last letter are dropped. Both sides of a comparison go through it.
-*/
-const stem = (word) => {
-	let root = word;
-	if (root.length > 4 && root.endsWith("ies")) root = `${root.slice(0, -3)}y`;
-	else if (root.length > 3 && root.endsWith("s") && !root.endsWith("ss")) root = root.slice(0, -1);
-	if (root.length > 5 && root.endsWith("ing")) root = root.slice(0, -3);
-	else if (root.length > 4 && root.endsWith("ed")) root = root.slice(0, -2);
-	if (root.length > 3 && root.endsWith("e")) root = root.slice(0, -1);
-	if (root.length > 4 && /([^aeiou])\1$/.test(root) && !root.endsWith("ss")) root = root.slice(0, -1);
-	return root;
-};
-/**
-* The bricks that answer a request: those whose name carries the most of its words (all of them
-* first), then those whose path or signature does. Nothing is returned when no word matches.
-*/
-function findBricks(bricks, request) {
-	const wanted = searchWords(request);
-	if (wanted.length === 0) return [];
-	const hits = [];
-	for (const brick of bricks) {
-		const inName = new Set(nameWords(brick.name).map(stem));
-		const inPath = new Set(nameWords(brick.path).map(stem));
-		const inSig = new Set(nameWords(brick.sig).map(stem));
-		let score = 0;
-		let named = 0;
-		let covered = 0;
-		for (const word of wanted) if (inName.has(word)) {
-			score += 3;
-			named += 1;
-			covered += 1;
-		} else if (inPath.has(word)) {
-			score += 1;
-			covered += 1;
-		} else if (inSig.has(word)) {
-			score += .5;
-			covered += 1;
-		}
-		if (covered < Math.ceil(wanted.length * .6)) continue;
-		if (named === 0 && wanted.length > 1) continue;
-		if (named === wanted.length) score += 2;
-		hits.push({
-			brick,
-			score
-		});
-	}
-	return hits.sort((a, b) => b.score - a.score || a.brick.path.localeCompare(b.brick.path) || a.brick.line - b.brick.line).slice(0, 8);
-}
-/** A single source that answers a request: every word of its concept is in the request. */
-function matchingSources(sources, request) {
-	const wanted = new Set(searchWords(request));
-	return sources.filter((source) => {
-		const words = searchWords([source.concept]);
-		return words.length > 0 && words.every((word) => wanted.has(word));
-	});
+	return out;
 }
-/** True when `path` is the owner (a file) or lies under it (a folder written with a final `/`). */
-function isOwner(source, path) {
-	const owner = source.owner.replaceAll("\\", "/");
-	const here = path.replaceAll("\\", "/");
-	return owner.endsWith("/") ? here.startsWith(owner) : here === owner;
+const scoreOf = (c) => c.relevance + c.mentioned + .3 * c.centrality;
+const byRank = (a, b) => scoreOf(b) - scoreOf(a) || (a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+/** The symbols of a file worth showing, best first: those the request names, then those most used. */
+function symbolsOf(candidate, cap) {
+	return [...candidate.bricks].sort((a, b) => (candidate.matched.get(b) ?? 0) - (candidate.matched.get(a) ?? 0) || b.refs - a.refs || a.line - b.line).slice(0, cap);
 }
+const lineOf = (brick) => `  ${brick.line}: ${brick.decl}`;
 /**
-* The functions of `added` (a path and its added lines) whose name carries every word of a single
-* source's concept while their file is not its owner: the concept has one home, and this is a second.
+* The map of `bricks` for `request` (a story's title and sheet, a sentence), within `budget` tokens.
+* Undefined when there is nothing exported to show.
 */
-function sourceClashes(files, added, sources) {
-	if (sources.length === 0) return [];
-	const clashes = [];
-	for (const file of files) {
-		const lines = added.get(file.path);
-		if (lines === void 0) continue;
-		for (const brick of bricksOf(file.path, file.text)) {
-			if (!lines.has(brick.line)) continue;
-			const words = new Set(nameWords(brick.name).map(stem));
-			for (const source of sources) {
-				if (isOwner(source, brick.path)) continue;
-				const concept = searchWords([source.concept]);
-				if (concept.length > 0 && concept.every((word) => words.has(word))) {
-					clashes.push({
-						name: brick.name,
-						path: brick.path,
-						line: brick.line,
-						concept: source.concept,
-						owner: source.owner
-					});
-					break;
-				}
+function repoMapOf(bricks, request, budget = MAP_TOKENS) {
+	const tokensLeft = Math.min(MAP_MAX_TOKENS, Math.max(0, Number.isFinite(budget) ? Math.floor(budget) : MAP_TOKENS));
+	const candidates = candidatesOf(bricks, request).sort(byRank);
+	if (candidates.length === 0 || tokensLeft === 0) return void 0;
+	const related = candidates.filter((c) => c.relevance > 0 || c.mentioned > 0);
+	const filler = candidates.filter((c) => c.relevance === 0 && c.mentioned === 0);
+	const room = tokensLeft * CHARS_PER_TOKEN - 57 - 64;
+	const fillerRoom = related.length === 0 ? room : Math.floor(room * FILLER_SHARE);
+	const blocks = [];
+	let chars = 0;
+	let shown = 0;
+	let fillerChars = 0;
+	let symbols = 0;
+	let left = candidates.length;
+	const take = (list, cap, limit, isFiller) => {
+		for (const candidate of list) {
+			const lines = symbolsOf(candidate, cap);
+			const fitting = [];
+			let size = candidate.path.length + 1;
+			for (const brick of lines) {
+				const add = lineOf(brick).length + 1;
+				if ((isFiller ? fillerChars : chars) + size + add > limit || chars + size + add > room) break;
+				fitting.push(brick);
+				size += add;
 			}
+			if (fitting.length === 0) continue;
+			fitting.sort((a, b) => a.line - b.line);
+			blocks.push(`${candidate.path}\n${fitting.map(lineOf).join("\n")}`);
+			chars += size;
+			if (isFiller) fillerChars += size;
+			shown += 1;
+			symbols += fitting.length;
+			left -= 1;
 		}
-	}
-	return clashes;
-}
-// ../../packages/core/dist/project-profile/profile-file.js
-/** The project profile: one short file, committed, written by the engine. */
-const PROFILE_PATH = `${METHOD_DIR}/profile.md`;
-/** The acceptance section for a place and how to reach it (one line each, never a secret). */
-function acceptanceText(place, how) {
-	const line = how.replace(/[\r\n]+/g, " ").trim().slice(0, 200);
-	return `- Place: ${place}${line === "" ? "" : `\n- How: ${line}`}`;
-}
-const HEADER = "<!-- Written by agentplugged: `npx agentplugged docs profile refresh` rewrites every section but Single sources, Acceptance and Notes. -->";
-const SOURCES_HEADING = "## Single sources";
-const ACCEPTANCE_HEADING = "## Acceptance";
-const NOTES_HEADING = "## Notes";
-const cell = (text) => text.replace(/[|\r\n]+/g, " ").trim();
-/** Rows kept per generated section: the file stays within `PROFILE_MAX_LINES` on a big product. */
-const ROW_CAPS = {
-	stack: 5,
-	commands: 10,
-	layout: 2,
-	conventions: 8,
-	advice: 6
-};
-/** The generated sections of the profile, from what the scan found. */
-function renderProfile(scan, kept) {
-	const lines = [
-		HEADER,
-		"# Project profile",
-		""
-	];
-	const section = (title, rows, empty) => {
-		if (rows.length === 0 && empty === void 0) return;
-		lines.push(`## ${title}`, ...rows.length === 0 ? [empty] : rows, "");
-	};
-	section("Stack", scan.stack.slice(0, ROW_CAPS.stack).map((row) => `- ${row}`), "- No code yet: run `npx agentplugged docs profile refresh` once the first story is merged.");
-	section("Commands", scan.commands.slice(0, ROW_CAPS.commands).map((command) => `- ${command.name}: \`${command.command}\` (${command.source})`), "- None found in the root manifests.");
-	section("Layout", scan.layout.slice(0, ROW_CAPS.layout).map((row) => `- ${row}`));
-	section("Conventions", scan.conventions.slice(0, ROW_CAPS.conventions).map((row) => `- ${row}`));
-	section("Advice", scan.advice.slice(0, ROW_CAPS.advice).map((item) => `- ${item.advice} Why: ${item.why}`));
-	lines.push(SOURCES_HEADING);
-	lines.push("One owner per concept: reuse it, never rewrite it elsewhere.");
-	lines.push("| Concept | Owner | Rule |", "| --- | --- | --- |");
-	for (const source of kept.sources) lines.push(`| ${cell(source.concept)} | ${cell(source.owner)} | ${cell(source.rule)} |`);
-	lines.push("", ACCEPTANCE_HEADING, kept.acceptance === "" ? "(not set)" : kept.acceptance.trimEnd());
-	lines.push("", NOTES_HEADING, kept.notes === "" ? "(none)" : kept.notes.trimEnd(), "");
-	return `${lines.join("\n")}`;
-}
-/** The single sources and the notes of an existing profile (what a refresh must keep). */
-function parseKept(text) {
-	const body = text.replace(/\r\n/g, "\n");
-	const start = body.indexOf(`\n${SOURCES_HEADING}\n`);
-	const notesAt = body.lastIndexOf(`\n${NOTES_HEADING}\n`);
-	const sources = [];
-	if (start !== -1) {
-		const next = body.indexOf("\n## ", start + 1);
-		const end = next === -1 ? body.length : next;
-		for (const row of body.slice(start, end).split("\n")) {
-			const cells = row.split("|").slice(1, -1).map((part) => part.trim());
-			if (cells.length !== 3 || cells[0] === "Concept" || /^-+$/.test(cells[0])) continue;
-			const [concept, owner, rule] = cells;
-			if (concept !== "" && owner !== "") sources.push({
-				concept,
-				owner,
-				rule
-			});
-		}
-	}
-	const acceptanceAt = body.indexOf(`\n${ACCEPTANCE_HEADING}\n`);
-	let acceptance = "";
-	if (acceptanceAt !== -1) {
-		const from = acceptanceAt + 13 + 2;
-		const stop = body.indexOf("\n## ", from);
-		acceptance = body.slice(from, stop === -1 ? body.length : stop).trim();
-		if (acceptance === "(not set)") acceptance = "";
-	}
-	const afterNotes = notesAt === -1 ? "" : body.slice(notesAt + 8 + 2);
-	const sourcesAfter = start > notesAt ? afterNotes.indexOf(`\n${SOURCES_HEADING}\n`) : -1;
-	let notes = (sourcesAfter === -1 ? afterNotes : afterNotes.slice(0, sourcesAfter)).trim();
-	if (notes === "(none)") notes = "";
-	return {
-		sources,
-		acceptance,
-		notes
 	};
-}
-/** The same profile with one single source added or replaced (the concept names it, case apart). */
-function withSource(kept, source) {
-	const same = (candidate) => candidate.concept.toLowerCase() === source.concept.toLowerCase();
+	take(related, SYMBOLS_PER_FILE, room, false);
+	take(filler, SYMBOLS_PER_FILLER, fillerRoom, true);
+	if (shown === 0) return void 0;
+	const footer = left > 0 ? `\n+${left} more files` : "";
+	const text = `${HEADER}\n${blocks.join("\n")}${footer}`;
 	return {
-		...kept,
-		sources: [...kept.sources.filter((item) => !same(item)), source]
+		text,
+		tokens: mapTokens(text),
+		files: shown,
+		symbols,
+		omitted_files: left
 	};
 }
 // ../../packages/core/dist/project-profile/scan.js
@@ -1309,8 +581,6 @@ async function scanProject(files) {
 	return out;
 }
 // ../../packages/core/dist/project-profile/project-command.js
-/** Where the engine keeps the registry it read: the machine's memory, outside Git. */
-const BRICKS_CACHE_PATH = `${METHOD_DIR}/.cache/bricks.json`;
 const invalid = (reason) => new AgentPluggedError(ErrorCode.INVALID_ARGUMENTS, "error.invalid_arguments", { reason });
 async function readText(context, path) {
 	try {
@@ -1326,11 +596,12 @@ async function singleSourcesOf(context) {
 }
 /** The profile file for a scan, the parts people wrote kept from `current`. */
 function profileFile(scan, current) {
-	return renderProfile(scan, current === void 0 ? {
+	const kept = current === void 0 ? {
 		sources: [],
 		acceptance: "",
 		notes: ""
-	} : parseKept(current));
+	} : parseKept(current);
+	return renderProfile(scan, kept);
 }
 /**
 * `docs profile [refresh]`: the project profile. Without `refresh`, the file as it would be written
@@ -1339,7 +610,7 @@ function profileFile(scan, current) {
 */
 async function showProfile(context, words) {
 	if (words[0] === "accept") return declareAcceptance(context, words.slice(1));
-	if (words.length > 1 || words.length === 1 && words[0] !== "refresh") return invalid(`docs profile ${words.join(" ")} (profile [refresh], or profile accept <local|staging> [how])`);
+	if (words.length > 1 || words.length === 1 && words[0] !== "refresh") return invalid(`docs profile ${words.join(" ")} (profile [refresh], or profile accept <preview|staging|local> [how])`);
 	const current = await readText(context, PROFILE_PATH);
 	const fresh = profileFile(await scanProject(context.files), current);
 	const same = current !== void 0 && current.replace(/\r\n/g, "\n") === fresh;
@@ -1360,12 +631,12 @@ async function showProfile(context, words) {
 	} };
 }
 /**
-* `docs profile accept <local|staging> [how…]`: where the acceptance run happens, decided with the
+* `docs profile accept <preview|staging|local> [how…]`: where the acceptance run happens, decided with the
 * creator and kept in the profile (a refresh never overwrites it).
 */
 async function declareAcceptance(context, words) {
 	const [place, ...how] = words;
-	if (place !== "local" && place !== "staging") return invalid("docs profile accept <local|staging> [how to reach it]");
+	if (!ACCEPTANCE_PLACES.some((known) => known === place)) return invalid("docs profile accept <preview|staging|local> [how to reach it]");
 	const current = await readText(context, PROFILE_PATH);
 	const kept = current === void 0 ? {
 		sources: [],
@@ -1384,45 +655,6 @@ async function declareAcceptance(context, words) {
 		lines: fresh.split("\n")
 	} };
 }
-/** The bricks at the commit the folder is on: read from the cache, or read again when it moved. */
-async function loadBricks(context) {
-	if (context.codeSource === void 0 || context.docsBase === void 0) return "no_code_source";
-	const head = await context.docsBase.read("HEAD", [PROFILE_PATH]).catch(() => void 0);
-	if (head === void 0) return "no_repository";
-	if (!head.found) return head.reason === "no_commit" ? "no_commit" : "no_repository";
-	const cached = await readText(context, BRICKS_CACHE_PATH);
-	if (cached !== void 0) try {
-		const parsed = JSON.parse(cached);
-		if (parsed.v === 1 && parsed.commit === head.commit && Array.isArray(parsed.bricks)) return {
-			bricks: parsed.bricks.flatMap((row) => typeof row[0] === "string" && (row[1] === "fn" || row[1] === "type") && typeof row[2] === "string" && Number.isInteger(row[3]) && typeof row[4] === "string" ? [{
-				name: row[0],
-				kind: row[1],
-				path: row[2],
-				line: row[3],
-				sig: row[4]
-			}] : []),
-			commit: head.commit
-		};
-	} catch {}
-	const tree = await context.codeSource.read(head.commit, (path, bytes) => isCodePath(path) && bytes <= BRICK_FILE_BYTES).catch(() => void 0);
-	if (tree === void 0) return "no_repository";
-	const bricks = buildBricks(tree);
-	await context.files.writeText(BRICKS_CACHE_PATH, JSON.stringify({
-		v: 1,
-		commit: head.commit,
-		bricks: bricks.map((brick) => [
-			brick.name,
-			brick.kind,
-			brick.path,
-			brick.line,
-			brick.sig
-		])
-	})).catch(() => void 0);
-	return {
-		bricks,
-		commit: head.commit
-	};
-}
 /**
 * `docs bricks <words>`: does something like this already exist? The bricks (functions and types)
 * whose names carry the words, best first, and the single source that owns the concept if one is
@@ -1432,17 +664,19 @@ async function loadBricks(context) {
 async function findInRegistry(context, words) {
 	if (words[0] === "own") return declareSource(context, words.slice(1));
 	if (words.length === 0) return invalid("docs bricks <words> | docs bricks own <concept> <path>");
-	const named = matchingSources(await singleSourcesOf(context), words);
-	const loaded = await loadBricks(context);
+	const sources = await singleSourcesOf(context);
+	const named = matchingSources(sources, words);
+	const loaded = await loadCodeMap(context);
 	if (typeof loaded === "string") return { bricks: {
 		query: words,
 		hits: [],
 		sources: named,
 		unavailable: loaded
 	} };
+	const bricks = bricksOfMap(loaded);
 	return { bricks: {
 		query: words,
-		hits: findBricks(loaded.bricks, words).map(({ brick }) => ({
+		hits: findBricks(bricks, words).map(({ brick }) => ({
 			name: brick.name,
 			kind: brick.kind,
 			path: brick.path,
@@ -1451,7 +685,7 @@ async function findInRegistry(context, words) {
 		})),
 		sources: named,
 		searched: {
-			total: loaded.bricks.length,
+			total: bricks.length,
 			commit: loaded.commit.slice(0, 12)
 		}
 	} };
@@ -1505,4 +739,38 @@ async function profileBrief(context) {
 		return;
 	}
 }
-export { REFERENCE_DIR as A, METHOD_CONFIG_PATH as C, METHOD_SUBDIRS as D, METHOD_GITIGNORE_PATH as E, ROOT_CONSTITUTION_PATH as M, referenceFilePath as N, MODELS_PATH as O, unexpected as S, METHOD_DIR as T, sourceWords as _, showProfile as a, reasonDetails as b, PROFILE_PATH as c, findTwins as d, MAX_FILE_BYTES as f, WordTable as g, isTestPath as h, profileFile as i, REFERENCE_LEGACY_PATH as j, POINTER_FILES as k, renderProfile as l, isReadableCode as m, findInRegistry as n, singleSourcesOf as o, isCodePath as p, profileBrief as r, scanProject as s, BRICKS_CACHE_PATH as t, sourceClashes as u, wordsOf as v, METHOD_CONSTITUTION_PATH as w, unavailable as x, AgentPluggedError as y };
+/**
+* `docs map <request…>`: the map of the code for a piece of work, the same one `start_story` hands
+* the agent for a story's sheet: the files that matter for the request and the signatures they
+* export, within the same budget. Without a request, the files the rest of the code leans on.
+*/
+async function showRepoMap(context, words) {
+	const loaded = await loadCodeMap(context);
+	if (typeof loaded === "string") return { map: {
+		tokens: 0,
+		files: 0,
+		symbols: 0,
+		omitted_files: 0,
+		unavailable: loaded
+	} };
+	return { map: repoMapOf(bricksOfMap(loaded), words.join(" "), 1500) ?? {
+		tokens: 0,
+		files: 0,
+		symbols: 0,
+		omitted_files: 0
+	} };
+}
+/**
+* The map of the repository for a request (a story's sheet), read from the registry of the commit
+* the folder is on: the files that matter and their exported signatures, within the budget.
+* Undefined when the code cannot be read or holds nothing to show; never a failure.
+*/
+async function repoMapFor(context, request, budget = MAP_TOKENS) {
+	try {
+		const loaded = await loadCodeMap(context);
+		return typeof loaded === "string" ? void 0 : repoMapOf(bricksOfMap(loaded), request, budget);
+	} catch {
+		return;
+	}
+}
+export { showProfile as a, scanProject as c, mapTokens as d, repoMapOf as f, repoMapFor as i, MAP_MAX_TOKENS as l, profileBrief as n, showRepoMap as o, profileFile as r, singleSourcesOf as s, findInRegistry as t, MAP_TOKENS as u };