agentplugged 1.2.0 → 1.4.0

package/dist/project-command.js

@@ -0,0 +1,1508 @@
+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";
+/**
+* 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.
+*/
+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;
+		}
+		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
+		});
+		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;
+			}
+		}
+		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",
+			path,
+			line: index + 1,
+			sig: line.trim().replace(/\s*[{(=].*$/, "").slice(0, SIG_MAX)
+		});
+	}
+	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));
+	});
+}
+/** 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;
+}
+/**
+* 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.
+*/
+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;
+				}
+			}
+		}
+	}
+	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();
+	return {
+		...kept,
+		sources: [...kept.sources.filter((item) => !same(item)), source]
+	};
+}
+// ../../packages/core/dist/project-profile/scan.js
+/** Longest manifest read (bytes): a larger one is data, not a manifest. */
+const MAX_MANIFEST = 2e5;
+const MAX_LAYOUT = 12;
+/** Root entries that are not product folders. */
+const NOT_LAYOUT = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	"out",
+	"target",
+	"vendor",
+	"coverage",
+	"tmp",
+	"temp",
+	"bin",
+	"obj",
+	"venv",
+	"env",
+	"docs",
+	"doc",
+	"scripts",
+	"public",
+	"assets",
+	"images",
+	"licenses",
+	"license"
+]);
+const TEST_FOLDERS = /* @__PURE__ */ new Set([
+	"test",
+	"tests",
+	"__tests__",
+	"spec",
+	"specs",
+	"e2e"
+]);
+function lower(entries) {
+	return new Map(entries.map((entry) => [entry.toLowerCase(), entry]));
+}
+/** The script a manifest names `name`, as a command, or undefined. */
+const pick = (record, name) => {
+	const value = record?.[name];
+	return typeof value === "string" && value.trim() !== "" ? value : void 0;
+};
+const asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+/** Libraries worth naming in the stack: a short, well-known set, found in a dependency list. */
+const KNOWN_PACKAGES = [
+	["react", "React"],
+	["vue", "Vue"],
+	["svelte", "Svelte"],
+	["next", "Next.js"],
+	["nuxt", "Nuxt"],
+	["@angular/core", "Angular"],
+	["express", "Express"],
+	["fastify", "Fastify"],
+	["@nestjs/core", "NestJS"],
+	["vitest", "Vitest"],
+	["jest", "Jest"],
+	["mocha", "Mocha"],
+	["@playwright/test", "Playwright"],
+	["cypress", "Cypress"],
+	["@biomejs/biome", "Biome"],
+	["eslint", "ESLint"],
+	["prettier", "Prettier"]
+];
+async function scanNode(reader, out) {
+	const raw = await reader.text("package.json");
+	if (raw === void 0) return;
+	let manifest;
+	try {
+		manifest = asRecord(JSON.parse(raw));
+	} catch {
+		out.stack.push("Node.js project (package.json is not valid JSON)");
+		return;
+	}
+	if (manifest === void 0) return;
+	const lockfiles = [
+		"pnpm-lock.yaml",
+		"yarn.lock",
+		"bun.lock",
+		"bun.lockb",
+		"package-lock.json"
+	].filter((name) => reader.entries.has(name));
+	const declared = pick(manifest, "packageManager")?.split("@")[0];
+	const manager = declared !== void 0 && declared !== "" ? declared : {
+		"pnpm-lock.yaml": "pnpm",
+		"yarn.lock": "yarn",
+		"bun.lock": "bun",
+		"bun.lockb": "bun",
+		"package-lock.json": "npm"
+	}[lockfiles[0] ?? ""] ?? "npm";
+	const typed = reader.entries.has("tsconfig.json");
+	const engines = pick(asRecord(manifest.engines), "node");
+	out.stack.push(`${typed ? "TypeScript" : "JavaScript"} on Node.js${engines === void 0 ? "" : ` ${engines}`}, ${manager} (package.json${lockfiles.length > 0 ? `, ${lockfiles[0]}` : ""})`);
+	const dependencies = {
+		...asRecord(manifest.dependencies),
+		...asRecord(manifest.devDependencies)
+	};
+	const known = KNOWN_PACKAGES.filter(([name]) => name in dependencies).map(([, label]) => label);
+	if (known.length > 0) out.stack.push(`Libraries: ${known.join(", ")} (package.json)`);
+	const scripts = asRecord(manifest.scripts);
+	const run = (name) => manager === "yarn" ? `yarn ${name}` : `${manager} run ${name}`;
+	const add = (kind, script, command = run(script)) => {
+		if (pick(scripts, script) !== void 0) out.commands.push({
+			name: kind,
+			command,
+			source: `package.json scripts.${script}`
+		});
+	};
+	add("test", "test", manager === "yarn" ? "yarn test" : `${manager} test`);
+	add("build", "build");
+	add("lint", "lint");
+	add("typecheck", "typecheck");
+	add("typecheck", "type-check");
+	add("format", "format");
+	add("run", "dev");
+	if (pick(scripts, "dev") === void 0) add("run", "start");
+	if (lockfiles.length > 1) out.advice.push({
+		advice: `Pick one package manager (${manager}) and delete the other lockfiles.`,
+		why: `${lockfiles.join(" and ")} are all committed: two managers rewrite each other's lockfile.`
+	});
+	else if (lockfiles.length === 1) out.advice.push({
+		advice: `Install with ${manager} only.`,
+		why: `${lockfiles[0]} is committed: another manager would rewrite it and change versions.`
+	});
+	if (manifest.workspaces !== void 0 || reader.entries.has("pnpm-workspace.yaml")) out.advice.push({
+		advice: "Run a package's commands from that package, not from the root, when you touch one.",
+		why: "the repository holds several packages (workspaces): the root command runs them all."
+	});
+}
+async function scanPython(reader, out) {
+	const pyproject = await reader.text("pyproject.toml");
+	const requirements = await reader.text("requirements.txt");
+	const hasSetup = reader.entries.has("setup.py") || reader.entries.has("pipfile");
+	if (pyproject === void 0 && requirements === void 0 && !hasSetup) return;
+	const runner = reader.entries.has("uv.lock") ? "uv run " : reader.entries.has("poetry.lock") ? "poetry run " : "";
+	const source = pyproject !== void 0 ? "pyproject.toml" : "requirements.txt";
+	const text = `${pyproject ?? ""}\n${requirements ?? ""}`.toLowerCase();
+	out.stack.push(`Python (${source}${runner === "" ? "" : `, ${runner.trim()}`})`);
+	if (/pytest/.test(text)) out.commands.push({
+		name: "test",
+		command: `${runner}pytest`,
+		source
+	});
+	if (/\[tool\.ruff|\bruff\b/.test(text)) out.commands.push({
+		name: "lint",
+		command: `${runner}ruff check`,
+		source
+	});
+	if (/\[tool\.mypy|\bmypy\b/.test(text)) out.commands.push({
+		name: "typecheck",
+		command: `${runner}mypy .`,
+		source
+	});
+	if (runner !== "") out.advice.push({
+		advice: `Run Python tools through \`${runner.trim()}\`.`,
+		why: `${runner.startsWith("uv") ? "uv.lock" : "poetry.lock"} is committed: a bare \`python\` or \`pytest\` runs outside the project environment.`
+	});
+}
+function scanSimple(reader, out) {
+	const has = (name) => reader.entries.has(name);
+	if (has("cargo.toml")) {
+		out.stack.push("Rust (Cargo.toml)");
+		out.commands.push({
+			name: "test",
+			command: "cargo test",
+			source: "Cargo.toml"
+		});
+		out.commands.push({
+			name: "build",
+			command: "cargo build",
+			source: "Cargo.toml"
+		});
+	}
+	if (has("go.mod")) {
+		out.stack.push("Go (go.mod)");
+		out.commands.push({
+			name: "test",
+			command: "go test ./...",
+			source: "go.mod"
+		});
+		out.commands.push({
+			name: "build",
+			command: "go build ./...",
+			source: "go.mod"
+		});
+		out.commands.push({
+			name: "lint",
+			command: "go vet ./...",
+			source: "go.mod"
+		});
+	}
+	if (has("pom.xml")) {
+		out.stack.push("Java (pom.xml)");
+		out.commands.push({
+			name: "test",
+			command: "mvn test",
+			source: "pom.xml"
+		});
+	}
+	const gradle = ["build.gradle", "build.gradle.kts"].find(has);
+	if (gradle !== void 0) {
+		const wrapper = has("gradlew") ? "./gradlew" : "gradle";
+		out.stack.push(`JVM, Gradle (${gradle})`);
+		out.commands.push({
+			name: "test",
+			command: `${wrapper} test`,
+			source: gradle
+		});
+		out.commands.push({
+			name: "build",
+			command: `${wrapper} build`,
+			source: gradle
+		});
+	}
+	const dotnet = [...reader.entries].find((name) => /\.(?:sln|slnx|csproj|fsproj)$/.test(name));
+	if (dotnet !== void 0) {
+		out.stack.push(`.NET (${dotnet})`);
+		out.commands.push({
+			name: "test",
+			command: "dotnet test",
+			source: dotnet
+		});
+		out.commands.push({
+			name: "build",
+			command: "dotnet build",
+			source: dotnet
+		});
+	}
+	if (has("gemfile")) {
+		out.stack.push("Ruby (Gemfile)");
+		if (has(".rspec")) out.commands.push({
+			name: "test",
+			command: "bundle exec rspec",
+			source: ".rspec"
+		});
+	}
+	if (has("mix.exs")) {
+		out.stack.push("Elixir (mix.exs)");
+		out.commands.push({
+			name: "test",
+			command: "mix test",
+			source: "mix.exs"
+		});
+	}
+	if (has("package.swift")) {
+		out.stack.push("Swift (Package.swift)");
+		out.commands.push({
+			name: "test",
+			command: "swift test",
+			source: "Package.swift"
+		});
+	}
+	if (has("pubspec.yaml")) out.stack.push("Dart (pubspec.yaml)");
+}
+async function scanComposer(reader, out) {
+	const raw = await reader.text("composer.json");
+	if (raw === void 0) return;
+	out.stack.push("PHP (composer.json)");
+	try {
+		if (asRecord(asRecord(JSON.parse(raw))?.scripts)?.test !== void 0) out.commands.push({
+			name: "test",
+			command: "composer test",
+			source: "composer.json scripts.test"
+		});
+	} catch {}
+}
+/** The targets of a Makefile the profile names (a target is a command only when it is written). */
+async function scanMake(reader, out) {
+	const text = await reader.text("Makefile");
+	if (text === void 0) return;
+	const targets = new Set([...text.matchAll(/^([a-z][\w-]*)\s*:(?!=)/gm)].map((match) => match[1]));
+	for (const [kind, target] of [
+		["test", "test"],
+		["build", "build"],
+		["lint", "lint"],
+		["format", "fmt"],
+		["format", "format"]
+	]) if (targets.has(target) && !out.commands.some((command) => command.name === kind)) out.commands.push({
+		name: kind,
+		command: `make ${target}`,
+		source: `Makefile ${target}:`
+	});
+}
+const TOOLING = [
+	[
+		["biome.json", "biome.jsonc"],
+		"Biome formats and lints",
+		"its config is committed"
+	],
+	[
+		[
+			".prettierrc",
+			".prettierrc.json",
+			".prettierrc.js",
+			"prettier.config.js"
+		],
+		"Prettier formats",
+		"its config is committed"
+	],
+	[
+		[
+			".eslintrc",
+			".eslintrc.json",
+			".eslintrc.js",
+			"eslint.config.js",
+			"eslint.config.mjs"
+		],
+		"ESLint lints",
+		"its config is committed"
+	],
+	[
+		["rustfmt.toml", ".rustfmt.toml"],
+		"rustfmt formats",
+		"its config is committed"
+	],
+	[
+		[".golangci.yml", ".golangci.yaml"],
+		"golangci-lint lints",
+		"its config is committed"
+	],
+	[
+		[".rubocop.yml"],
+		"RuboCop lints",
+		"its config is committed"
+	],
+	[
+		[".editorconfig"],
+		"EditorConfig sets indentation and line endings",
+		".editorconfig is committed"
+	]
+];
+const CI_FILES = [
+	".gitlab-ci.yml",
+	"azure-pipelines.yml",
+	"jenkinsfile",
+	".travis.yml",
+	"bitbucket-pipelines.yml",
+	"appveyor.yml"
+];
+async function scanConventions(reader, files, out) {
+	for (const [names, label, why] of TOOLING) {
+		const found = names.find((name) => reader.entries.has(name.toLowerCase()));
+		if (found === void 0) continue;
+		out.conventions.push(`${label} (${found}).`);
+		if (label.startsWith("Biome") || label.startsWith("Prettier") || label.startsWith("rustfmt")) out.advice.push({
+			advice: `Format with the project's formatter, not by hand.`,
+			why: `${found}: ${why}, and a style-only diff is noise in a review.`
+		});
+	}
+	for (const pinned of [
+		".nvmrc",
+		".node-version",
+		".python-version",
+		".tool-versions"
+	]) {
+		if (!reader.entries.has(pinned)) continue;
+		const value = (await reader.text(pinned))?.split("\n")[0]?.trim();
+		out.conventions.push(`Runtime version pinned: ${value ?? "see file"} (${pinned}).`);
+	}
+	let workflows = [];
+	try {
+		workflows = (await files.listEntries?.(".github/workflows") ?? []).filter((name) => /\.ya?ml$/i.test(name));
+	} catch {
+		workflows = [];
+	}
+	if (workflows.length > 0) out.conventions.push(`CI: GitHub Actions (${workflows.slice(0, 4).join(", ")}).`);
+	const ci = CI_FILES.find((name) => reader.entries.has(name));
+	if (ci !== void 0) out.conventions.push(`CI: ${ci}.`);
+	if (reader.entries.has("dockerfile") || reader.entries.has("docker-compose.yml")) out.conventions.push("Containers: Dockerfile or docker-compose.yml at the root.");
+	if (reader.entries.has("tsconfig.json")) out.conventions.push("TypeScript: tsconfig.json at the root.");
+}
+/** Reads the product's root and says what it is. Never throws: an unreadable file says nothing. */
+async function scanProject(files) {
+	const out = {
+		stack: [],
+		commands: [],
+		conventions: [],
+		layout: [],
+		advice: []
+	};
+	let names = [];
+	try {
+		names = await files.listEntries?.("") ?? [];
+	} catch {
+		names = [];
+	}
+	const byLower = lower(names);
+	const reader = {
+		entries: new Set(byLower.keys()),
+		async text(name) {
+			const actual = byLower.get(name.toLowerCase());
+			if (actual === void 0) return void 0;
+			try {
+				const text = await files.readText(actual);
+				return text.length > MAX_MANIFEST ? void 0 : text.replace(/\r\n/g, "\n");
+			} catch {
+				return;
+			}
+		}
+	};
+	await scanNode(reader, out);
+	await scanPython(reader, out);
+	scanSimple(reader, out);
+	await scanComposer(reader, out);
+	await scanMake(reader, out);
+	await scanConventions(reader, files, out);
+	const folders = [];
+	for (const name of names) {
+		if (name.includes(".") || name.startsWith("_") || NOT_LAYOUT.has(name.toLowerCase())) continue;
+		if (folders.length >= 30) break;
+		try {
+			if ((await files.listEntries?.(name) ?? []).length > 0) folders.push(name);
+		} catch {}
+	}
+	const tests = folders.filter((name) => TEST_FOLDERS.has(name.toLowerCase()));
+	const product = folders.filter((name) => !TEST_FOLDERS.has(name.toLowerCase()));
+	if (product.length > 0) out.layout.push(`Folders: ${product.slice(0, MAX_LAYOUT).join(", ")}.`);
+	if (tests.length > 0) out.layout.push(`Tests live in: ${tests.join(", ")}.`);
+	if (!out.commands.some((command) => command.name === "test") && out.stack.length > 0) out.advice.push({
+		advice: "No test command was found: ask the creator for it before inventing one.",
+		why: "no manifest or Makefile of the root defines it; a guessed command proves nothing."
+	});
+	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 {
+		return await context.files.exists(path) ? await context.files.readText(path) : void 0;
+	} catch {
+		return;
+	}
+}
+/** The single sources the team declared (the table of the profile), empty without a profile. */
+async function singleSourcesOf(context) {
+	const text = await readText(context, PROFILE_PATH);
+	return text === void 0 ? [] : parseKept(text).sources;
+}
+/** The profile file for a scan, the parts people wrote kept from `current`. */
+function profileFile(scan, current) {
+	return renderProfile(scan, current === void 0 ? {
+		sources: [],
+		acceptance: "",
+		notes: ""
+	} : parseKept(current));
+}
+/**
+* `docs profile [refresh]`: the project profile. Without `refresh`, the file as it would be written
+* now (and whether the file on disk still says the same); with it, the file is written. The profile
+* is read from the root files of the product, so it is never invented.
+*/
+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])`);
+	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;
+	if (words[0] === "refresh") {
+		if (!same) await context.files.writeText(PROFILE_PATH, fresh);
+		return { profile: {
+			path: PROFILE_PATH,
+			written: !same,
+			state: current === void 0 ? "created" : same ? "current" : "refreshed",
+			lines: fresh.split("\n")
+		} };
+	}
+	return { profile: {
+		path: PROFILE_PATH,
+		written: false,
+		state: current === void 0 ? "absent" : same ? "current" : "stale",
+		lines: fresh.split("\n")
+	} };
+}
+/**
+* `docs profile accept <local|staging> [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]");
+	const current = await readText(context, PROFILE_PATH);
+	const kept = current === void 0 ? {
+		sources: [],
+		acceptance: "",
+		notes: ""
+	} : parseKept(current);
+	const fresh = renderProfile(await scanProject(context.files), {
+		...kept,
+		acceptance: acceptanceText(place, how.join(" "))
+	});
+	await context.files.writeText(PROFILE_PATH, fresh);
+	return { profile: {
+		path: PROFILE_PATH,
+		written: true,
+		state: "refreshed",
+		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
+* declared. `docs bricks own <concept> <path> [rule…]` declares a single source: the concept then
+* has one home, and a second one added by a story is flagged at its review.
+*/
+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);
+	if (typeof loaded === "string") return { bricks: {
+		query: words,
+		hits: [],
+		sources: named,
+		unavailable: loaded
+	} };
+	return { bricks: {
+		query: words,
+		hits: findBricks(loaded.bricks, words).map(({ brick }) => ({
+			name: brick.name,
+			kind: brick.kind,
+			path: brick.path,
+			line: brick.line,
+			sig: brick.sig
+		})),
+		sources: named,
+		searched: {
+			total: loaded.bricks.length,
+			commit: loaded.commit.slice(0, 12)
+		}
+	} };
+}
+async function declareSource(context, words) {
+	const [concept, owner, ...rule] = words;
+	if (concept === void 0 || owner === void 0 || concept.length < 2) return invalid("docs bricks own <concept> <path> [rule…]");
+	const bare = owner.replaceAll("\\", "/").split("/").filter((part) => part !== "" && part !== ".").join("/");
+	if (bare === "" || bare.startsWith("/") || bare.split("/").includes("..")) return invalid(`docs bricks own ${concept} ${owner} (a path of the product)`);
+	if (!await context.files.exists(bare)) return invalid(`docs bricks own ${concept} ${owner} (no such file or folder)`);
+	const source = {
+		concept: concept.replace(/[|\r\n]+/g, " ").trim(),
+		owner: (await context.files.listEntries?.(bare) ?? []).length > 0 ? `${bare}/` : bare,
+		rule: rule.join(" ").slice(0, 160)
+	};
+	const current = await readText(context, PROFILE_PATH);
+	const scan = await scanProject(context.files);
+	const kept = withSource(current === void 0 ? {
+		sources: [],
+		acceptance: "",
+		notes: ""
+	} : parseKept(current), source);
+	await context.files.writeText(PROFILE_PATH, renderProfile(scan, kept));
+	return { bricks: {
+		query: [concept],
+		hits: [],
+		sources: [source],
+		declared: source
+	} };
+}
+/** Longest list of each kind in the brief. */
+const BRIEF_ROWS = 6;
+/**
+* The profile brief for a story: read from the root files now (a stale file never misleads) with the
+* single sources of the profile. Undefined when the product has no stack to describe yet.
+*/
+async function profileBrief(context) {
+	try {
+		const scan = await scanProject(context.files);
+		if (scan.stack.length === 0 && scan.commands.length === 0) return void 0;
+		const sources = await singleSourcesOf(context);
+		return {
+			path: PROFILE_PATH,
+			stack: scan.stack.slice(0, BRIEF_ROWS).map((row) => row.slice(0, 140)),
+			commands: scan.commands.slice(0, 12).map((c) => `${c.name}: ${c.command}`),
+			single_sources: sources.slice(0, 10).map((s) => `${s.concept} -> ${s.owner}${s.rule === "" ? "" : ` (${s.rule})`}`),
+			advice: scan.advice.slice(0, 3).map((a) => `${a.advice} Why: ${a.why}`.slice(0, 220)),
+			ask: "npx agentplugged docs bricks <words>"
+		};
+	} catch {
+		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 };