@happyvertical/smrt-dev-mcp 0.40.37 → 0.40.39

package/dist/{knowledge-BPbgCtVJ.js → knowledge-DUUhTM5u.js}

@@ -1,8 +1,9 @@
-import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
+import { existsSync, lstatSync, opendirSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { MODULE_DOC_HASH_PREFIX, readAgentModuleDocs } from "@happyvertical/smrt-core/knowledge";
+import { ManifestAdapter, OxcScanner } from "@happyvertical/smrt-scanner";
 //#region src/knowledge/index.ts
 var SDK_PACKAGE_NAMES = /* @__PURE__ */ new Set([
 	"@happyvertical/ai",
@@ -40,6 +41,39 @@ var WALK_SKIP_DIRS = /* @__PURE__ */ new Set([
 	"dist",
 	"node_modules"
 ]);
+/** Used only when neither pnpm-workspace.yaml nor package.json#workspaces exists. */
+var WORKSPACE_GLOB_FALLBACK = ["packages/*"];
+/**
+* Bounds total directory-entry work across every workspace glob. This is a
+* cardinality budget rather than a depth cap: valid deeply nested workspaces
+* remain discoverable, while broad or repeated globstars fail loudly before
+* they can amplify into unbounded filesystem work.
+*/
+var MAX_WORKSPACE_GLOB_TRAVERSAL_ENTRIES = 1e4;
+/** Prevents a broad but sub-budget glob from fanning out package reads. */
+var MAX_DISCOVERED_WORKSPACE_PACKAGES = 512;
+/** Bounds simultaneous OxcScanner instances and their filesystem handles. */
+var MAX_SCANNER_CONCURRENCY = 8;
+/** Caps the downstream package fallback so a large product stays in budget. */
+var MAX_FALLBACK_PACKAGES = 8;
+/** Kept in sync with `tools/introspect-project.ts` so both paths see one corpus. */
+var SCAN_INCLUDE = [
+	"**/*.ts",
+	"**/*.tsx",
+	"**/*.js",
+	"**/*.jsx"
+];
+var SCAN_EXCLUDE = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/.git/**",
+	"**/.smrt/**",
+	"**/*.d.ts",
+	"**/*.test.ts",
+	"**/*.spec.ts",
+	"**/__tests__/**"
+];
 var STALE_PATTERNS = [
 	{
 		code: "stale-have-namespace",
@@ -65,45 +99,185 @@ var STALE_PATTERNS = [
 async function buildKnowledgeIndex(options = {}) {
 	const rootDir = findProjectRoot(options.rootDir ?? process.cwd());
 	const includeDocs = options.includeDocs ?? true;
-	const packageDirs = discoverProjectPackageDirs(rootDir);
-	const packages = packageDirs.map((dir) => readKnowledgePackage(rootDir, dir, includeDocs));
+	const { globs, globSource, dirs: discoveredPackageDirs, diagnostics: discoveryDiagnostics } = discoverProjectPackageDirs(rootDir);
+	const resolvedRoot = realpathSync(rootDir);
+	const packageDirs = [];
+	const packages = [];
+	for (const dir of discoveredPackageDirs) {
+		if (confinedRealPath(resolvedRoot, dir) === void 0) {
+			discoveryDiagnostics.push({
+				severity: "error",
+				code: "workspace-package-root-escape",
+				message: "Rejected a workspace package whose real path changed or escaped the workspace root before it could be read.",
+				remedy: "Keep workspace package paths stable and inside the workspace root throughout knowledge discovery."
+			});
+			continue;
+		}
+		packageDirs.push(dir);
+		packages.push(readKnowledgePackage(rootDir, dir, includeDocs));
+	}
+	await applyScannerFallbacks(packages, packageDirs.filter((dir) => resolve(dir) !== resolve(rootDir)).map((dir) => `${relative(rootDir, dir).replaceAll("\\", "/")}/**`));
 	packages.push(...discoverInstalledSdkPackages(rootDir, packageDirs, includeDocs));
-	const scopedPackages = filterKnowledgePackages(dedupePackages(packages), options);
+	const uniquePackages = dedupePackages(packages);
+	const scopedPackages = filterKnowledgePackages(uniquePackages, options);
 	const smrtPackages = scopedPackages.filter((pkg) => pkg.kind === "smrt");
 	const sdkPackages = scopedPackages.filter((pkg) => pkg.kind === "sdk");
+	const coverage = buildCoverage({
+		rootDir,
+		globs,
+		globSource,
+		packageDirs,
+		packages: uniquePackages
+	});
 	return {
-		schemaVersion: 1,
+		schemaVersion: 2,
 		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
 		rootDir,
 		packages: scopedPackages,
 		smrtPackages,
 		sdkPackages,
-		relationshipsV2: summarizeRelationshipsV2(scopedPackages)
+		relationshipsV2: summarizeRelationshipsV2(scopedPackages),
+		coverage,
+		diagnostics: buildIndexDiagnostics(rootDir, uniquePackages, coverage, discoveryDiagnostics)
+	};
+}
+function buildCoverage(options) {
+	return {
+		workspaceGlobs: options.globs,
+		workspaceGlobSource: options.globSource,
+		packageDirs: options.packageDirs.map((dir) => relative(options.rootDir, dir) || "."),
+		packagesWithObjects: options.packages.filter((pkg) => pkg.objects.length > 0).map((pkg) => `${pkg.name} (${pkg.objects.length}, ${pkg.objectSource})`),
+		packagesWithoutObjects: options.packages.filter((pkg) => pkg.objects.length === 0).map((pkg) => ({
+			name: pkg.name,
+			reason: pkg.objectSourceReason ?? pkg.objectSource,
+			checkedPaths: pkg.checkedObjectPaths,
+			remedy: remedyForReason(pkg)
+		}))
 	};
 }
+function remedyForReason(pkg) {
+	const reason = pkg.objectSourceReason ?? "";
+	if (reason.startsWith("manifest-objects-owned-by-other-packages")) return `${pkg.relativeDirectory || "."} has an aggregate or stale manifest owned by other packages. Regenerate it (pnpm build in that package) so it declares this package's own objects.`;
+	if (reason.startsWith("scanner-failed")) return `Source scanning failed for ${pkg.relativeDirectory || "."}; fix the parse error or generate a manifest with pnpm build.`;
+	if (reason === "no-smrt-objects-in-sources") return "No @smrt() classes were found in this package. Expected if it is a UI, contract, or tooling package.";
+	return `Add @smrt() classes, or run pnpm build in ${pkg.relativeDirectory || "."} to emit .smrt/manifest.json.`;
+}
+/**
+* Turns a discovery failure into an explicit signal.
+*
+* A zero-object index used to be indistinguishable from a project with no
+* relationships, so callers acted on empty context as if it were an answer
+* (#2143). The zero case is therefore error-grade and names what was checked.
+*/
+function buildIndexDiagnostics(rootDir, packages, coverage, discoveryDiagnostics = []) {
+	const diagnostics = [...discoveryDiagnostics];
+	if (packages.reduce((total, pkg) => total + pkg.objects.length, 0) === 0) diagnostics.push({
+		severity: "error",
+		code: "no-smrt-objects-discovered",
+		message: [
+			`No SMRT objects were discovered under ${rootDir}.`,
+			`Workspace globs (${coverage.workspaceGlobSource}): ${coverage.workspaceGlobs.join(", ") || "(none)"}.`,
+			`Package directories checked (${coverage.packageDirs.length}): ${coverage.packageDirs.join(", ") || "(none)"}.`,
+			"Treat this as a discovery failure, not as evidence that the project has no SMRT model."
+		].join(" "),
+		checkedPaths: [...new Set(packages.flatMap((pkg) => pkg.checkedObjectPaths))],
+		remedy: [
+			"Confirm rootDir is the workspace root;",
+			"confirm pnpm-workspace.yaml `packages:` covers the directories that hold @smrt() classes (for example apps/*);",
+			"run `pnpm build` in the owning package to emit .smrt/manifest.json;",
+			"then re-run. Cross-check with introspect-project on the same root."
+		].join(" ")
+	});
+	for (const pkg of packages) {
+		const reason = pkg.objectSourceReason ?? "";
+		if (reason.startsWith("manifest-objects-owned-by-other-packages")) {
+			diagnostics.push({
+				severity: "warning",
+				code: "foreign-manifest-objects",
+				message: `${pkg.name}: every object in the discovered manifest is owned by another package (${reason}); it was rejected instead of being counted as this package's.`,
+				packageName: pkg.name,
+				checkedPaths: pkg.checkedObjectPaths,
+				remedy: remedyForReason(pkg)
+			});
+			continue;
+		}
+		if (reason.startsWith("rejected ")) {
+			diagnostics.push({
+				severity: "warning",
+				code: "partial-foreign-manifest-objects",
+				message: `${pkg.name}: ${reason}.`,
+				packageName: pkg.name,
+				checkedPaths: pkg.checkedObjectPaths,
+				remedy: remedyForReason(pkg)
+			});
+			continue;
+		}
+		if (reason.startsWith("scanner-failed")) diagnostics.push({
+			severity: "warning",
+			code: "scanner-fallback-failed",
+			message: `${pkg.name}: ${reason}`,
+			packageName: pkg.name,
+			checkedPaths: pkg.checkedObjectPaths,
+			remedy: remedyForReason(pkg)
+		});
+	}
+	diagnostics.push(...buildDuplicateIdentityDiagnostics(packages));
+	return diagnostics;
+}
+/**
+* Reports one table claimed by more than one package. Relationships-v2 already
+* counts it once, but the duplication itself usually means a stale or
+* re-qualified generated artifact, which the caller should know about (#2143).
+*/
+function buildDuplicateIdentityDiagnostics(packages) {
+	const duplicates = [];
+	for (const [identity, entries] of groupObjectsByIdentity(packages)) {
+		if (collapseIdentityGroup(entries).length >= entries.length) continue;
+		duplicates.push([identity, [...new Set(entries.map((entry) => entry.pkg.name))]]);
+	}
+	if (duplicates.length === 0) return [];
+	const sample = duplicates.slice(0, 5).map(([identity, names]) => `${identity} (${names.join(" + ")})`).join("; ");
+	return [{
+		severity: "warning",
+		code: "duplicate-object-identity",
+		message: `${duplicates.length} object identit${duplicates.length === 1 ? "y is" : "ies are"} reported by more than one package: ${sample}${duplicates.length > 5 ? "; …" : ""}. Relationships-v2 counts each once.`,
+		remedy: "Usually a stale or aggregate generated artifact in a consuming package that re-qualifies its dependencies' objects. Regenerate it (pnpm build) so each package reports only the objects it declares."
+	}];
+}
 async function checkKnowledgeFreshness(options = {}) {
 	return checkKnowledgeFreshnessFromIndex(await buildKnowledgeIndex(options), options);
 }
 async function checkKnowledgeFreshnessFromIndex(index, options = {}) {
 	const issues = [];
 	const changedFiles = options.changed ? getChangedFiles(index.rootDir) : void 0;
-	for (const pkg of index.packages.filter((item) => item.kind !== "sdk")) {
+	const hasMemberPackages = index.packages.some((item) => item.kind !== "sdk" && !item.isWorkspaceRoot);
+	const memberDirectories = index.packages.filter((item) => item.kind !== "sdk" && !item.isWorkspaceRoot && item.relativeDirectory).map((item) => item.relativeDirectory);
+	const isNestedMember = (pkg) => Boolean(pkg.relativeDirectory) && memberDirectories.some((directory) => directory !== pkg.relativeDirectory && pkg.relativeDirectory.startsWith(`${directory}/`));
+	for (const pkg of index.packages.filter((item) => item.kind !== "sdk" && !(item.isWorkspaceRoot && hasMemberPackages))) {
 		const packageJsonPath = join(pkg.directory, "package.json");
-		if (!pkg.hasAgentsMd) issues.push({
+		const nested = isNestedMember(pkg);
+		if (!pkg.hasAgentsMd && !nested) issues.push({
 			severity: "error",
 			code: "missing-agents-md",
 			message: "Workspace package is missing canonical AGENTS.md",
 			file: relative(index.rootDir, join(pkg.directory, "AGENTS.md")),
 			packageName: pkg.name
 		});
-		if (!pkg.hasClaudeMd) issues.push({
+		if (nested && pkg.hasAgentsMd) issues.push({
+			severity: "error",
+			code: "nested-agents-md",
+			message: "Nested workspace package must not define AGENTS.md; move it to the parent package as a linked agents/<module>.md",
+			file: relative(index.rootDir, join(pkg.directory, "AGENTS.md")),
+			packageName: pkg.name
+		});
+		if (!pkg.hasClaudeMd && !nested) issues.push({
 			severity: "error",
 			code: "missing-claude-shim",
 			message: "Workspace package is missing CLAUDE.md compatibility shim",
 			file: relative(index.rootDir, join(pkg.directory, "CLAUDE.md")),
 			packageName: pkg.name
 		});
-		else if (!pkg.hasClaudeShim) issues.push({
+		else if (pkg.hasClaudeMd && !pkg.hasClaudeShim) issues.push({
 			severity: "error",
 			code: "claude-not-shim",
 			message: "CLAUDE.md must contain only @AGENTS.md",
@@ -120,6 +294,7 @@ async function checkKnowledgeFreshnessFromIndex(index, options = {}) {
 				packageName: pkg.name
 			});
 		}
+		if (pkg.isPrivate) continue;
 		if (!pkg.files.includes("AGENTS.md")) issues.push({
 			severity: "error",
 			code: "package-files-missing-agents",
@@ -262,11 +437,14 @@ async function buildReviewContext(options = {}) {
 			sdkPackages: selectedSdkPackages,
 			sourceFiles: changedFiles,
 			extraContext: options.focus,
+			detail: options.detail,
 			moduleDocHints: {
 				changedFiles,
 				text: [options.focus, options.documentation].filter(Boolean).join("\n")
 			}
-		})
+		}),
+		coverage: index.coverage,
+		diagnostics: index.diagnostics
 	};
 }
 async function smrtReview(options = {}) {
@@ -277,7 +455,9 @@ async function smrtReview(options = {}) {
 		selectedPackages: context.selectedPackages,
 		selectedSdkPackages: context.selectedSdkPackages,
 		...mode !== "prompt-bundle" ? { deterministicFindings: context.deterministicFindings } : {},
-		...mode !== "findings" ? { promptBundle: context.promptBundle } : {}
+		...mode !== "findings" ? { promptBundle: context.promptBundle } : {},
+		coverage: context.coverage,
+		diagnostics: context.diagnostics
 	};
 }
 async function buildArchitectureContext(options = {}) {
@@ -307,8 +487,11 @@ async function buildArchitectureContext(options = {}) {
 			sdkPackages: selectedSdkPackages,
 			sourceFiles: [],
 			extraContext: text,
+			detail: options.detail,
 			moduleDocHints: { text }
-		})
+		}),
+		coverage: index.coverage,
+		diagnostics: index.diagnostics
 	};
 }
 async function smrtArchitecture(options = {}) {
@@ -341,6 +524,7 @@ function renderKnowledgeIndexMarkdown(index) {
 		`- polymorphic associations: ${index.relationshipsV2.polymorphicAssociations}`,
 		`- UUID columns: ${index.relationshipsV2.uuidColumns}`,
 		"",
+		...renderDiagnosticsSection(index.diagnostics),
 		"## Packages",
 		""
 	];
@@ -377,34 +561,261 @@ function renderFreshnessResult(result) {
 	}
 	return lines.join("\n");
 }
+/**
+* Nearest ancestor that declares a workspace (#2143).
+*
+* The old rule also required a literal `packages/` directory, which silently
+* mis-rooted every `apps/*`-shaped product. A workspace declaration is the
+* actual signal; `startDir` is the fallback so single-package repos still work.
+*/
 function findProjectRoot(startDir) {
 	let current = resolve(startDir);
 	for (;;) {
-		if (existsSync(join(current, "pnpm-workspace.yaml")) && existsSync(join(current, "packages"))) return current;
+		if (existsSync(join(current, "pnpm-workspace.yaml"))) return current;
+		if (readPackageJsonWorkspaceGlobs(current).length > 0) return current;
 		const parent = dirname(current);
 		if (parent === current) return resolve(startDir);
 		current = parent;
 	}
 }
-function discoverWorkspacePackageDirs(rootDir) {
-	const packagesDir = join(rootDir, "packages");
-	if (!existsSync(packagesDir)) return [];
-	return readdirSync(packagesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join(packagesDir, entry.name)).filter((dir) => existsSync(join(dir, "package.json"))).sort();
+function readPackageJsonWorkspaceGlobs(dir) {
+	const workspaces = objectRecord(readJson(join(dir, "package.json"))).workspaces;
+	return Array.isArray(workspaces) ? stringArray(workspaces) : stringArray(objectRecord(workspaces).packages);
+}
+function readWorkspaceGlobs(rootDir) {
+	const pnpmWorkspacePath = join(rootDir, "pnpm-workspace.yaml");
+	if (existsSync(pnpmWorkspacePath)) {
+		const globs = parseYamlStringList(readFileSync(pnpmWorkspacePath, "utf8"), "packages");
+		if (globs.length > 0) return {
+			globs,
+			source: "pnpm-workspace.yaml"
+		};
+	}
+	const packageJsonGlobs = readPackageJsonWorkspaceGlobs(rootDir);
+	if (packageJsonGlobs.length > 0) return {
+		globs: packageJsonGlobs,
+		source: "package.json#workspaces"
+	};
+	return {
+		globs: [...WORKSPACE_GLOB_FALLBACK],
+		source: "fallback"
+	};
+}
+/**
+* Reads a top-level `key:` string list out of `pnpm-workspace.yaml`.
+*
+* Deliberately dependency-free: the shape consumed here is a fixed, tiny list
+* of globs, and a read-only dev server should not pull in a YAML parser for it.
+* Handles both block sequences and a single-line flow sequence.
+*/
+function parseYamlStringList(content, key) {
+	const keyPattern = new RegExp(`^${escapeRegExp(key)}\\s*:\\s*(.*)$`);
+	const values = [];
+	let inBlock = false;
+	for (const line of content.split(/\r?\n/)) {
+		if (!inBlock) {
+			const match = line.match(keyPattern);
+			if (!match) continue;
+			const rest = (match[1] ?? "").trim();
+			if (rest.startsWith("[")) return rest.replace(/^\[/, "").replace(/\]\s*$/, "").split(",").map((entry) => unquoteYamlScalar(entry)).filter(Boolean);
+			if (rest !== "" && !rest.startsWith("#")) continue;
+			inBlock = true;
+			continue;
+		}
+		if (line.trim() === "" || line.trimStart().startsWith("#")) continue;
+		const item = line.match(/^\s+-\s*(.+?)\s*$/);
+		if (!item) break;
+		const value = unquoteYamlScalar(item[1] ?? "");
+		if (value) values.push(value);
+	}
+	return values;
+}
+function unquoteYamlScalar(value) {
+	const trimmed = value.trim();
+	const quoted = trimmed.match(/^(['"])([\s\S]*?)\1/);
+	if (quoted) return (quoted[2] ?? "").trim();
+	return trimmed.replace(/\s+#.*$/, "").trim();
+}
+var WorkspaceGlobTraversalLimitError = class extends Error {
+	glob;
+	constructor(glob) {
+		super(`Workspace glob traversal exceeded ${MAX_WORKSPACE_GLOB_TRAVERSAL_ENTRIES} directory entries while expanding ${glob}`);
+		this.glob = glob;
+		this.name = "WorkspaceGlobTraversalLimitError";
+	}
+};
+function expandWorkspaceGlobs(rootDir, globs) {
+	const diagnostics = [];
+	const positiveGlobs = [];
+	const negations = [];
+	for (const rawGlob of globs) {
+		const negated = rawGlob.trim().startsWith("!");
+		const glob = normalizeGlob(negated ? rawGlob.trim().slice(1) : rawGlob.trim());
+		const unsafeReason = unsafeWorkspaceGlobReason(glob);
+		if (unsafeReason) {
+			diagnostics.push({
+				severity: "error",
+				code: "unsafe-workspace-glob",
+				message: `Rejected workspace glob ${JSON.stringify(rawGlob)}: ${unsafeReason}.`,
+				remedy: "Keep every workspace glob relative to the declared workspace root; absolute paths and parent-directory (`..`) segments are not supported."
+			});
+			continue;
+		}
+		if (!glob) continue;
+		if (negated) negations.push(globToRegExp(glob));
+		else positiveGlobs.push(glob);
+	}
+	const matched = /* @__PURE__ */ new Set();
+	const budget = { entries: 0 };
+	try {
+		for (const glob of positiveGlobs) for (const dir of expandGlob(rootDir, glob, budget)) matched.add(dir);
+	} catch (error) {
+		if (!(error instanceof WorkspaceGlobTraversalLimitError)) throw error;
+		diagnostics.push({
+			severity: "error",
+			code: "workspace-glob-expansion-limit",
+			message: error.message,
+			remedy: "Narrow the workspace package globs or remove repeated broad globstars. Discovery stopped without reading any partially matched package set."
+		});
+		return {
+			dirs: [],
+			diagnostics,
+			fatal: true
+		};
+	}
+	const resolvedRoot = realpathSync(rootDir);
+	const confined = [...matched].map((dir) => confinedRealPath(resolvedRoot, dir)).filter((dir) => dir !== void 0);
+	if (confined.length !== matched.size) diagnostics.push({
+		severity: "error",
+		code: "workspace-glob-root-escape",
+		message: "Rejected a workspace package directory whose real path resolves outside the workspace root.",
+		remedy: "Keep workspace packages inside the workspace root and do not route workspace globs through symlinks to sibling directories."
+	});
+	return {
+		dirs: [...new Set(confined)].filter((dir) => existsSync(join(dir, "package.json"))).filter((dir) => {
+			const rel = relative(rootDir, dir).replaceAll("\\", "/");
+			return rel !== "" && !negations.some((pattern) => pattern.test(rel));
+		}).sort(),
+		diagnostics,
+		fatal: false
+	};
+}
+function normalizeGlob(glob) {
+	return glob.trim().replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/+$/, "");
 }
-function discoverProjectPackageDirs(rootDir) {
-	const workspaceDirs = discoverWorkspacePackageDirs(rootDir);
-	if (existsSync(join(rootDir, "package.json")) && hasLocalDomainArtifact(rootDir)) return [rootDir, ...workspaceDirs.filter((dir) => dir !== rootDir)];
-	return workspaceDirs;
+function unsafeWorkspaceGlobReason(glob) {
+	if (glob.includes("\0")) return "NUL bytes are not valid path content";
+	if (isAbsolute(glob) || /^[A-Za-z]:\//.test(glob)) return "absolute paths are outside the workspace trust boundary";
+	if (glob.split("/").includes("..")) return "parent-directory segments can escape the workspace root";
 }
-function hasLocalDomainArtifact(rootDir) {
-	return [
-		join(rootDir, ".smrt", "smrt-knowledge.json"),
-		join(rootDir, ".smrt", "manifest.json"),
-		join(rootDir, "dist", "smrt-knowledge.json"),
-		join(rootDir, "dist", "manifest.json"),
-		join(rootDir, "src", "manifest", "smrt-knowledge.json"),
-		join(rootDir, "src", "manifest", "manifest.json")
-	].some((path) => existsSync(path));
+function confinedRealPath(resolvedRoot, candidate) {
+	try {
+		const rel = relative(resolvedRoot, realpathSync(candidate));
+		if (rel === "" || !isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`)) return candidate;
+	} catch {}
+}
+function expandGlob(rootDir, glob, budget) {
+	const segments = glob.split("/").filter((segment) => segment !== "");
+	if (segments.length === 0) return [];
+	let current = [rootDir];
+	for (const [segmentIndex, segment] of segments.entries()) {
+		const next = [];
+		for (const dir of current) {
+			if (segment === "**") {
+				next.push(dir, ...descendantDirs(dir, budget, glob));
+				continue;
+			}
+			if (segment.includes("*")) {
+				const pattern = globToRegExp(segment);
+				next.push(...childDirs(dir, budget, glob).filter((child) => pattern.test(basename(child))));
+				continue;
+			}
+			const literal = join(dir, segment);
+			const isFinalSegment = segmentIndex === segments.length - 1;
+			if (isDirectory(literal) || isFinalSegment && isSymbolicLink(literal)) next.push(literal);
+		}
+		current = [...new Set(next)];
+		if (current.length === 0) break;
+	}
+	return current;
+}
+function childDirs(dir, budget, glob) {
+	const children = [];
+	try {
+		const directory = opendirSync(dir);
+		try {
+			let entry = directory.readSync();
+			while (entry !== null) {
+				budget.entries += 1;
+				if (budget.entries > MAX_WORKSPACE_GLOB_TRAVERSAL_ENTRIES) throw new WorkspaceGlobTraversalLimitError(glob);
+				if (entry.isDirectory() && !WALK_SKIP_DIRS.has(entry.name)) children.push(join(dir, entry.name));
+				entry = directory.readSync();
+			}
+		} finally {
+			directory.closeSync();
+		}
+		return children;
+	} catch (error) {
+		if (error instanceof WorkspaceGlobTraversalLimitError) throw error;
+		return children;
+	}
+}
+function descendantDirs(dir, budget, glob) {
+	const descendants = [];
+	const pending = [dir];
+	for (let index = 0; index < pending.length; index += 1) {
+		const children = childDirs(pending[index], budget, glob);
+		descendants.push(...children);
+		pending.push(...children);
+	}
+	return descendants;
+}
+function isDirectory(path) {
+	try {
+		return lstatSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function isSymbolicLink(path) {
+	try {
+		return lstatSync(path).isSymbolicLink();
+	} catch {
+		return false;
+	}
+}
+/**
+* Translates a workspace glob into an anchored regular expression. `*` stays
+* within one path segment; `**` spans any depth (and collapses so `a/**` also
+* matches `a`).
+*/
+function globToRegExp(glob) {
+	const ANY_DEPTH = "\0";
+	const ANY_SEGMENT = "
";
+	const source = glob.replace(/\*\*/g, ANY_DEPTH).replace(/\*/g, ANY_SEGMENT).replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replaceAll(`/${ANY_DEPTH}`, "(?:/.*)?").replaceAll(`${ANY_DEPTH}/`, "(?:.*/)?").replaceAll(ANY_DEPTH, ".*").replaceAll(ANY_SEGMENT, "[^/]*");
+	return new RegExp(`^${source}$`);
+}
+function discoverProjectPackageDirs(rootDir) {
+	const { globs, source } = readWorkspaceGlobs(rootDir);
+	const expansion = expandWorkspaceGlobs(rootDir, globs);
+	const dirs = expansion.fatal ? [] : existsSync(join(rootDir, "package.json")) ? [rootDir, ...expansion.dirs.filter((dir) => resolve(dir) !== resolve(rootDir))] : expansion.dirs;
+	if (dirs.length > MAX_DISCOVERED_WORKSPACE_PACKAGES) return {
+		globs,
+		globSource: source,
+		dirs: [],
+		diagnostics: [...expansion.diagnostics, {
+			severity: "error",
+			code: "workspace-package-limit",
+			message: `Workspace discovery found ${dirs.length} packages, exceeding the ${MAX_DISCOVERED_WORKSPACE_PACKAGES}-package limit.`,
+			remedy: "Narrow the workspace package globs. Discovery stopped without reading any partially matched package set."
+		}]
+	};
+	return {
+		globs,
+		globSource: source,
+		dirs,
+		diagnostics: expansion.diagnostics
+	};
 }
 function discoverInstalledSdkPackages(rootDir, packageDirs, includeDocs) {
 	return [join(rootDir, "node_modules", "@happyvertical"), ...packageDirs.map((dir) => join(dir, "node_modules", "@happyvertical"))].filter((scopeDir, index, all) => existsSync(scopeDir) && all.indexOf(scopeDir) === index).flatMap((scopeDir) => readdirSync(scopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map((entry) => {
@@ -454,7 +865,14 @@ function readKnowledgePackage(rootDir, directory, includeDocs) {
 	const domainKnowledge = readDomainKnowledge(directory);
 	const docSource = hasAgentsMd ? "AGENTS.md" : fallbackClaudeDoc ? "CLAUDE.md" : null;
 	const manifest = readManifest(directory);
-	const objects = domainKnowledge ? readDomainKnowledgeObjects(domainKnowledge.content) : manifest ? readManifestObjects(manifest.content) : [];
+	const resolvedObjects = resolvePackageObjects({
+		packageName: name,
+		directory,
+		rootDir,
+		domainKnowledge,
+		manifest
+	});
+	const objects = resolvedObjects.objects;
 	const prompts = domainKnowledge ? readDomainKnowledgePrompts(domainKnowledge.content, directory, rootDir) : readPrompts(directory, rootDir);
 	const smrtDependencies = Object.keys(allDeps).filter((dep) => dep.startsWith("@happyvertical/smrt-")).sort();
 	const sdkDependencies = Object.keys(allDeps).filter((dep) => SDK_PACKAGE_NAMES.has(dep)).sort();
@@ -485,8 +903,131 @@ function readKnowledgePackage(rootDir, directory, includeDocs) {
 		objects,
 		prompts,
 		mcpTools: domainKnowledge ? domainMcpTools(domainKnowledge.content) : mcpTools(objects),
-		relationshipFeatures: relationshipFeatures(objects)
+		relationshipFeatures: relationshipFeatures(objects),
+		isWorkspaceRoot: resolve(directory) === resolve(rootDir),
+		isPrivate: packageJson.private === true,
+		objectSource: resolvedObjects.source,
+		objectSourceReason: resolvedObjects.reason,
+		checkedObjectPaths: resolvedObjects.checkedPaths
+	};
+}
+/** Artifact paths consulted for a package's objects, in precedence order. */
+function objectArtifactCandidates(directory) {
+	return [
+		join(directory, ".smrt", "smrt-knowledge.json"),
+		join(directory, "dist", "smrt-knowledge.json"),
+		join(directory, "src", "manifest", "smrt-knowledge.json"),
+		join(directory, "src", "manifest", "manifest.json"),
+		join(directory, ".smrt", "manifest.json"),
+		join(directory, "dist", "manifest.json")
+	];
+}
+function resolvePackageObjects(options) {
+	const checkedPaths = objectArtifactCandidates(options.directory).map((path) => relativeOrAbsolute(options.rootDir, path));
+	if (options.domainKnowledge) return {
+		objects: readDomainKnowledgeObjects(options.domainKnowledge.content),
+		source: "domain-artifact",
+		checkedPaths
 	};
+	if (!options.manifest) return {
+		objects: [],
+		source: "none",
+		reason: "no-artifact",
+		checkedPaths
+	};
+	const { owned, foreignCount } = partitionOwnedObjects(options.manifest.content, options.packageName);
+	const objects = readManifestObjects({ objects: owned });
+	if (objects.length === 0) return {
+		objects: [],
+		source: "none",
+		reason: foreignCount > 0 ? `manifest-objects-owned-by-other-packages (${foreignCount} rejected)` : "manifest-has-no-objects",
+		checkedPaths
+	};
+	return {
+		objects,
+		source: "manifest",
+		reason: foreignCount > 0 ? `rejected ${foreignCount} manifest object(s) owned by other packages` : void 0,
+		checkedPaths
+	};
+}
+function relativeOrAbsolute(rootDir, path) {
+	const rel = relative(rootDir, path);
+	return rel && !rel.startsWith("..") ? rel : path;
+}
+/**
+* Resolves objects from source when no artifact could supply them (#2143).
+*
+* `introspect-project` already reports `manifestSource: "scanner"` and works on
+* an unbuilt checkout. Without the same fallback here, an unbuilt package
+* silently contributed nothing and the two tools disagreed about one root —
+* which was the defect underneath every symptom in #2143.
+*
+* Mutates in place because `mcpTools` and `relationshipFeatures` are derived
+* from `objects` and have to be recomputed together.
+*/
+async function applyScannerFallback(pkg, extraExcludes = []) {
+	if (pkg.objectSource !== "none") return;
+	if (!hasScannableSources(pkg.directory)) {
+		pkg.objectSourceReason = `${pkg.objectSourceReason ?? "no-artifact"}; no-typescript-sources`;
+		return;
+	}
+	try {
+		const objects = await scanPackageObjects(pkg.directory, pkg.name, extraExcludes);
+		if (objects.length === 0) {
+			pkg.objectSourceReason = "no-smrt-objects-in-sources";
+			return;
+		}
+		pkg.objects = objects;
+		pkg.objectSource = "scanner";
+		pkg.objectSourceReason = void 0;
+		pkg.mcpTools = mcpTools(objects);
+		pkg.relationshipFeatures = relationshipFeatures(objects);
+	} catch (error) {
+		pkg.objectSourceReason = `scanner-failed: ${messageFromError(error)}`;
+	}
+}
+async function applyScannerFallbacks(packages, memberExcludes) {
+	for (let offset = 0; offset < packages.length; offset += MAX_SCANNER_CONCURRENCY) await Promise.all(packages.slice(offset, offset + MAX_SCANNER_CONCURRENCY).map((pkg) => applyScannerFallback(pkg, pkg.isWorkspaceRoot ? memberExcludes : [])));
+}
+/**
+* Stops at the first candidate instead of walking a whole tree.
+*
+* Deliberately unbounded in depth: a package may keep its models at
+* `src/features/billing/models/internal/Invoice.ts`, and a shallow probe would
+* report "no TypeScript sources" for a package `OxcScanner` can actually read.
+*/
+function hasScannableSources(directory) {
+	let entries;
+	try {
+		entries = readdirSync(directory, { withFileTypes: true });
+	} catch {
+		return false;
+	}
+	const subdirectories = [];
+	for (const entry of entries) {
+		if (entry.isDirectory()) {
+			if (!WALK_SKIP_DIRS.has(entry.name)) subdirectories.push(join(directory, entry.name));
+			continue;
+		}
+		if (entry.isFile() && /\.(tsx?|jsx?)$/.test(entry.name) && !entry.name.endsWith(".d.ts") && !entry.name.endsWith(".test.ts") && !entry.name.endsWith(".spec.ts")) return true;
+	}
+	return subdirectories.some((child) => hasScannableSources(child));
+}
+async function scanPackageObjects(directory, packageName, extraExcludes = []) {
+	const { results, resolved } = await new OxcScanner({
+		cwd: directory,
+		include: SCAN_INCLUDE,
+		exclude: [...SCAN_EXCLUDE, ...extraExcludes]
+	}).scanAndResolve();
+	const decorated = resolved.filter((classDef) => classDef.hasSmartDecorator);
+	if (decorated.length === 0) return [];
+	return readManifestObjects(new ManifestAdapter().toManifest(decorated, {
+		packageName,
+		typeAliases: results.typeAliases
+	}));
+}
+function messageFromError(error) {
+	return error instanceof Error ? error.message : String(error);
 }
 function readDomainKnowledge(directory) {
 	for (const path of [
@@ -521,6 +1062,40 @@ function readManifest(directory) {
 	}
 	return null;
 }
+/**
+* Rejects objects a manifest does not own (#2143).
+*
+* A runtime `.smrt/manifest.json` is frequently an *aggregate*: it registers
+* every object reachable from the app, including its dependencies'. Counting
+* those as the package's own doubles Relationships-v2 (a stale 759KB
+* `packages/cli/.smrt/manifest.json` reported 200 foreignKey / 413 UUID against
+* a real 89 / 206). Ownership is decided per object, so an aggregate still
+* contributes the objects it genuinely owns.
+*/
+function partitionOwnedObjects(manifest, packageName) {
+	const objects = objectRecord(manifest.objects);
+	const owned = {};
+	let foreignCount = 0;
+	for (const [key, raw] of Object.entries(objects)) {
+		if (manifestObjectIsOwned(objectRecord(raw), packageName)) {
+			owned[key] = raw;
+			continue;
+		}
+		foreignCount += 1;
+	}
+	return {
+		owned,
+		foreignCount
+	};
+}
+function manifestObjectIsOwned(object, packageName) {
+	const declared = typeof object.packageName === "string" ? object.packageName : void 0;
+	if (declared) return declared === packageName;
+	const qualifiedName = typeof object.qualifiedName === "string" ? object.qualifiedName : void 0;
+	const qualifier = qualifiedName?.includes(":") ? qualifiedName.slice(0, qualifiedName.lastIndexOf(":")) : void 0;
+	if (qualifier) return qualifier === packageName;
+	return true;
+}
 function readManifestObjects(manifest) {
 	const objects = objectRecord(manifest.objects);
 	return Object.values(objects).map((raw) => {
@@ -656,8 +1231,105 @@ function domainMcpTools(manifest) {
 		operation: surface.operation
 	})).sort((a, b) => a.name.localeCompare(b.name));
 }
+/**
+* Identity of the table an object maps to, used to avoid counting one table
+* twice (#2143).
+*
+* A consuming app's generated artifact can re-qualify a dependency's objects
+* under the app's own package name (observed: 18 of `apps/work-web`'s 21
+* artifact objects are classes declared in `packages/work`, same tables). Name
+* prefixes cannot detect that, so corpus-level facts are keyed by class plus
+* table instead.
+*/
+function objectIdentity(object) {
+	return `${object.className}::${object.tableName ?? object.collection ?? ""}`;
+}
+/**
+* True when either package declares the other as a dependency.
+*
+* This is what separates a re-qualified copy from a coincidence. A consuming
+* package can only restate its *dependencies'* objects, so a shared identity
+* across a dependency edge is one table reported twice. Two unrelated packages
+* that happen to share a class and table name (observed: `Account::accounts` in
+* both smrt-messages and smrt-ledgers) are genuinely distinct objects and must
+* both keep contributing their fields.
+*/
+function hasDependencyEdge(a, b) {
+	return dependsOn(a, b.name) || dependsOn(b, a.name);
+}
+/**
+* Picks the copy that owns the class within one connected group.
+*
+* Ownership follows the dependency direction: a consumer can restate its
+* *dependency's* objects, never the reverse, so the entry that the most other
+* members of the group depend on is the declaring package. Provenance alone is
+* not enough — preferring a scanner copy kept `smrt-support`'s compatibility
+* subtype over the canonical `smrt-projects` model and changed the facts.
+*/
+function pickOwningEntry(entries) {
+	let best = entries[0];
+	let bestScore = -1;
+	for (const entry of entries) {
+		const score = entries.filter((other) => other !== entry && dependsOn(other.pkg, entry.pkg.name)).length;
+		if (score > bestScore) {
+			best = entry;
+			bestScore = score;
+		}
+	}
+	return best;
+}
+function dependsOn(pkg, name) {
+	return name in pkg.dependencies || name in pkg.devDependencies || name in pkg.peerDependencies;
+}
+function dedupeObjectsByIdentity(packages) {
+	return [...groupObjectsByIdentity(packages).values()].flatMap((entries) => collapseIdentityGroup(entries).map((entry) => entry.object));
+}
+function groupObjectsByIdentity(packages) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const pkg of packages) for (const object of pkg.objects) {
+		const identity = objectIdentity(object);
+		const entries = groups.get(identity) ?? [];
+		entries.push({
+			pkg,
+			object
+		});
+		groups.set(identity, entries);
+	}
+	return groups;
+}
+/**
+* Collapses entries linked by dependency edges, leaving unrelated same-named
+* objects intact.
+*
+* Grouping is by connected component, not a greedy first match: when two
+* independent consumers both restate one shared dependency's object, neither
+* consumer has an edge to the other, so a greedy pass would keep both and
+* double-count the very table this exists to collapse. Packages arrive
+* name-sorted, so the result is stable.
+*/
+function collapseIdentityGroup(entries) {
+	if (entries.length === 1) return entries;
+	const parent = entries.map((_, index) => index);
+	const find = (index) => {
+		let root = index;
+		while (parent[root] !== root) root = parent[root];
+		return root;
+	};
+	for (let a = 0; a < entries.length; a += 1) for (let b = a + 1; b < entries.length; b += 1) {
+		if (!hasDependencyEdge(entries[a].pkg, entries[b].pkg)) continue;
+		const rootA = find(a);
+		const rootB = find(b);
+		if (rootA !== rootB) parent[rootB] = rootA;
+	}
+	const components = /* @__PURE__ */ new Map();
+	for (const [index, entry] of entries.entries()) {
+		const root = find(index);
+		components.set(root, [...components.get(root) ?? [], entry]);
+	}
+	return [...components.values()].map((component) => component.length === 1 ? component[0] : pickOwningEntry(component));
+}
 function summarizeRelationshipsV2(packages) {
-	const objects = packages.flatMap((pkg) => pkg.objects);
+	const objects = dedupeObjectsByIdentity(packages);
 	const fields = objects.flatMap((object) => object.fields);
 	return {
 		foreignKeyFields: fields.filter((field) => field.type === "foreignKey").length,
@@ -710,7 +1382,7 @@ function shouldScanStalePatternFile(rootDir, filePath) {
 function buildReviewFindings(index, changedFiles, selectedPackages) {
 	const issues = [];
 	for (const pkg of selectedPackages) {
-		const changedPackageFiles = changedFiles.filter((file) => file === pkg.relativeDirectory || file.startsWith(`${pkg.relativeDirectory}/`));
+		const changedPackageFiles = changedFiles.filter((file) => packageOwnsFile(pkg, file, index.packages));
 		if (!pkg.agentDoc && pkg.kind === "smrt") issues.push({
 			severity: "warning",
 			code: "missing-package-expertise",
@@ -769,14 +1441,47 @@ function buildReviewFindings(index, changedFiles, selectedPackages) {
 	}
 	return issues;
 }
+/**
+* Joins a package-relative path onto a package's workspace-relative directory.
+*
+* The workspace root can itself be an indexed package — including the
+* single-package layout #2143 added — and its `relativeDirectory` is the empty
+* string. Naive interpolation emits `/AGENTS.md`, an absolute filesystem path,
+* instead of the project-relative path callers are told to read.
+*/
+function packageRelativePath(pkg, path) {
+	return pkg.relativeDirectory ? `${pkg.relativeDirectory}/${path}` : path;
+}
+/**
+* Workspace-relative paths of a package's authored documentation.
+*
+* Shared with the MCP transport layer so the summary projection and the
+* Markdown bundle can never disagree about where a doc lives.
+*/
+function packageDocPaths(pkg) {
+	return [...pkg.docSource ? [packageRelativePath(pkg, pkg.docSource)] : [], ...pkg.moduleDocs.map((doc) => packageRelativePath(pkg, doc.path))];
+}
+/**
+* True when a workspace-relative changed file belongs to `pkg`.
+*
+* A workspace-root package has an empty `relativeDirectory`, so the nested-path
+* test would compare against a leading `/` and never match — which silently
+* selected no packages for exactly the single-package layout #2143 added. The
+* root instead owns any path no member package owns, mirroring the
+* member-excluded scan in `applyScannerFallbacks`.
+*/
+function packageOwnsFile(pkg, file, siblings) {
+	if (pkg.relativeDirectory) return file === pkg.relativeDirectory || file.startsWith(`${pkg.relativeDirectory}/`);
+	return !siblings.some((member) => member !== pkg && member.relativeDirectory && (file === member.relativeDirectory || file.startsWith(`${member.relativeDirectory}/`)));
+}
 function isPackageManifestFile(pkg, file) {
-	return file === `${pkg.relativeDirectory}/package.json`;
+	return file === packageRelativePath(pkg, "package.json");
 }
 function isPackageAgentDocFile(pkg, file) {
-	return file === `${pkg.relativeDirectory}/AGENTS.md` || pkg.moduleDocs.some((doc) => file === `${pkg.relativeDirectory}/${doc.path}`);
+	return file === packageRelativePath(pkg, "AGENTS.md") || pkg.moduleDocs.some((doc) => file === packageRelativePath(pkg, doc.path));
 }
 function isPublicEntrypointFile(pkg, file) {
-	const sourcePrefix = `${pkg.relativeDirectory}/src/`;
+	const sourcePrefix = packageRelativePath(pkg, "src/");
 	if (!file.startsWith(sourcePrefix)) return false;
 	const sourcePath = file.slice(sourcePrefix.length);
 	return sourcePath === "index.ts" || sourcePath === "index.tsx" || sourcePath === "index.js" || sourcePath.startsWith("api/") || sourcePath.startsWith("cli/") || sourcePath.startsWith("mcp/") || sourcePath.startsWith("tools/");
@@ -785,7 +1490,7 @@ function buildArchitectureRecommendations(context, ideaText) {
 	return {
 		smrtPackages: context.selectedPackages.map((pkg) => pkg.name),
 		sdkPackages: context.selectedSdkPackages.map((pkg) => pkg.name),
-		objectModelSketch: buildObjectModelSketch(context.selectedPackages),
+		objectModelSketch: buildObjectModelSketch(context.selectedPackages, context.diagnostics),
 		risks: buildArchitectureRisks(context.selectedPackages, ideaText),
 		questions: buildArchitectureQuestions(context.selectedPackages, ideaText),
 		notes: [
@@ -795,10 +1500,12 @@ function buildArchitectureRecommendations(context, ideaText) {
 		]
 	};
 }
-function buildObjectModelSketch(packages) {
+function buildObjectModelSketch(packages, diagnostics = []) {
+	const blocking = diagnostics.find((diagnostic) => diagnostic.code === "no-smrt-objects-discovered");
+	if (blocking) return [`No object model could be derived: ${blocking.message}`, `Remediation: ${blocking.remedy ?? "verify workspace discovery."}`];
 	const lines = packages.flatMap((pkg) => {
 		const objects = pkg.objects.filter((object) => object.extends !== "SmrtCollection").slice(0, 6).map((object) => object.className);
-		if (objects.length === 0) return [`${pkg.name}: use package services or templates; no manifest objects indexed.`];
+		if (objects.length === 0) return [`${pkg.name}: use package services or templates; no manifest objects indexed (${pkg.objectSourceReason ?? pkg.objectSource}).`];
 		return [`${pkg.name}: start from ${objects.join(", ")}.`];
 	});
 	return lines.length > 0 ? lines : ["Define the core domain as SmrtObject classes with explicit relationships and generated surfaces."];
@@ -832,7 +1539,8 @@ function buildArchitectureQuestions(packages, ideaText) {
 }
 function selectPackagesForFiles(index, changedFiles) {
 	const selected = /* @__PURE__ */ new Set();
-	for (const file of changedFiles) for (const pkg of domainPackages(index)) if (file === pkg.relativeDirectory || file.startsWith(`${pkg.relativeDirectory}/`)) selected.add(pkg);
+	const candidates = domainPackages(index);
+	for (const file of changedFiles) for (const pkg of candidates) if (packageOwnsFile(pkg, file, index.packages)) selected.add(pkg);
 	return [...selected].sort((a, b) => a.name.localeCompare(b.name));
 }
 function selectPackages(index, options) {
@@ -848,15 +1556,21 @@ function selectPackages(index, options) {
 		if (includesToken(text, pkg.name.replace("@happyvertical/smrt-", "")) || text.includes(pkg.name.toLowerCase()) || pkg.objects.some((object) => includesToken(text, object.className.toLowerCase()))) selected.add(pkg);
 	}
 	if (selected.size === 0 && options.scope === "local") for (const pkg of domainPackages(index).filter((item) => scopeAllowsPackage(item, "local"))) selected.add(pkg);
-	if (selected.size === 0 && options.scope !== "sdk") for (const name of [
-		"@happyvertical/smrt-core",
-		"@happyvertical/smrt-config",
-		"@happyvertical/smrt-cli",
-		"@happyvertical/smrt-scanner",
-		"@happyvertical/smrt-dev-mcp"
-	]) {
-		const pkg = index.smrtPackages.find((item) => item.name === name);
-		if (pkg) selected.add(pkg);
+	if (selected.size === 0 && options.scope !== "sdk") {
+		for (const name of [
+			"@happyvertical/smrt-core",
+			"@happyvertical/smrt-config",
+			"@happyvertical/smrt-cli",
+			"@happyvertical/smrt-scanner",
+			"@happyvertical/smrt-dev-mcp"
+		]) {
+			const pkg = index.smrtPackages.find((item) => item.name === name);
+			if (pkg) selected.add(pkg);
+		}
+		if (selected.size === 0) {
+			const contributing = domainPackages(index).filter((pkg) => pkg.objects.length > 0 && scopeAllowsPackage(pkg, options.scope) && !pkg.relativeDirectory.includes("node_modules")).sort((a, b) => b.objects.length - a.objects.length).slice(0, MAX_FALLBACK_PACKAGES);
+			for (const pkg of contributing) selected.add(pkg);
+		}
 	}
 	return [...selected].sort((a, b) => a.name.localeCompare(b.name));
 }
@@ -898,12 +1612,14 @@ function packageMatches(pkg, query) {
 	return pkg.name.toLowerCase() === normalized || pkg.name.toLowerCase().includes(normalized) || shortName.toLowerCase() === normalized || pkg.relativeDirectory.toLowerCase().endsWith(`/${normalized}`);
 }
 function buildPromptBundle(options) {
-	const render = (pkg) => renderPackageContext(pkg, options.moduleDocHints);
+	const detail = options.detail ?? "summary";
+	const render = (pkg) => renderPackageContext(pkg, options.moduleDocHints, detail);
 	const contextMarkdown = [
 		`# ${options.title}`,
 		"",
 		`Baseline root: ${options.index.rootDir}`,
 		"",
+		...renderDiagnosticsSection(options.index.diagnostics),
 		"## Task",
 		"",
 		options.task,
@@ -924,13 +1640,24 @@ function buildPromptBundle(options) {
 	];
 	return {
 		title: options.title,
-		instructions: "Use the supplied SMRT knowledge context as source material. Return concrete findings or architecture guidance with package names and source references. Do not assume model-provider access.",
+		instructions: ["Use the supplied SMRT knowledge context as source material. Return concrete findings or architecture guidance with package names and source references. Do not assume model-provider access.", detail === "summary" ? "Authored package docs are listed by path rather than embedded; read the ones you need, or re-request with detail: \"full\"." : ""].filter(Boolean).join(" "),
 		contextMarkdown: contextMarkdown.join("\n"),
 		selectedPackages: options.packages.map((pkg) => pkg.name),
 		selectedSdkPackages: options.sdkPackages.map((pkg) => pkg.name),
 		sourceFiles: options.sourceFiles
 	};
 }
+function renderDiagnosticsSection(diagnostics) {
+	if (diagnostics.length === 0) return [];
+	const lines = ["## Diagnostics", ""];
+	for (const diagnostic of diagnostics) {
+		lines.push(`- [${diagnostic.severity.toUpperCase()}] ${diagnostic.code}: ${diagnostic.message}`);
+		if (diagnostic.checkedPaths && diagnostic.checkedPaths.length > 0) lines.push(`  - checked: ${diagnostic.checkedPaths.join(", ")}`);
+		if (diagnostic.remedy) lines.push(`  - remedy: ${diagnostic.remedy}`);
+	}
+	lines.push("");
+	return lines;
+}
 /**
 * Which of a package's module docs to embed for this request (#2108).
 *
@@ -946,7 +1673,8 @@ function selectModuleDocs(pkg, hints) {
 		embedded: [],
 		scoped: false
 	};
-	const packageFiles = (hints?.changedFiles ?? []).filter((file) => file === pkg.relativeDirectory || file.startsWith(`${pkg.relativeDirectory}/`));
+	const prefix = pkg.relativeDirectory ? `${pkg.relativeDirectory}/` : "";
+	const packageFiles = (hints?.changedFiles ?? []).filter((file) => file === pkg.relativeDirectory || file.startsWith(prefix));
 	const text = hints?.text ?? "";
 	if (packageFiles.length === 0 && text.trim() === "") return {
 		embedded: all,
@@ -954,7 +1682,7 @@ function selectModuleDocs(pkg, hints) {
 	};
 	const matched = all.filter((doc) => {
 		const segment = new RegExp(`(^|[/.])${escapeRegExp(doc.module)}([/.]|$)`);
-		return packageFiles.some((file) => segment.test(file.slice(pkg.relativeDirectory.length + 1)) || file === `${pkg.relativeDirectory}/${doc.path}`) || includesToken(text, doc.module);
+		return packageFiles.some((file) => segment.test(file.slice(prefix.length)) || file === packageRelativePath(pkg, doc.path)) || includesToken(text, doc.module);
 	});
 	return matched.length > 0 ? {
 		embedded: matched,
@@ -967,7 +1695,7 @@ function selectModuleDocs(pkg, hints) {
 function escapeRegExp(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function renderPackageContext(pkg, hints) {
+function renderPackageContext(pkg, hints, detail = "full") {
 	const { embedded, scoped } = selectModuleDocs(pkg, hints);
 	const lines = [
 		`### ${pkg.name}`,
@@ -976,6 +1704,7 @@ function renderPackageContext(pkg, hints) {
 		`- kind: ${pkg.kind}`,
 		`- directory: ${pkg.relativeDirectory}`,
 		`- domain knowledge: ${pkg.domainKnowledgePath ?? "(manifest fallback)"}`,
+		`- object source: ${pkg.objectSource}${pkg.objectSourceReason ? ` (${pkg.objectSourceReason})` : ""}`,
 		`- docs: ${[pkg.docSource ?? "(none)", ...pkg.moduleDocs.map((doc) => doc.path)].join(", ")}`,
 		`- relationship features: ${pkg.relationshipFeatures.join(", ") || "(none)"}`,
 		`- SDK deps: ${pkg.sdkDependencies.join(", ") || "(none)"}`,
@@ -984,14 +1713,20 @@ function renderPackageContext(pkg, hints) {
 		`- objects: ${pkg.objects.slice(0, 20).map((object) => object.qualifiedName ?? object.className).join(", ")}`
 	];
 	if (pkg.objects.length > 20) lines.push(`- object count: ${pkg.objects.length}`);
+	if (detail === "summary") {
+		const docPaths = packageDocPaths(pkg);
+		if (docPaths.length > 0) lines.push("", `> Authored docs not embedded (read on demand, or re-request with detail: "full"): ${docPaths.join(", ")}`);
+		lines.push("");
+		return lines.join("\n");
+	}
 	if (pkg.agentDoc) lines.push("", pkg.agentDoc.trim());
 	for (const doc of embedded) {
-		lines.push("", `#### ${pkg.relativeDirectory}/${doc.path}`, "");
+		lines.push("", `#### ${packageRelativePath(pkg, doc.path)}`, "");
 		lines.push(doc.content.trim());
 	}
 	if (scoped) {
 		const omitted = pkg.moduleDocs.filter((doc) => !embedded.includes(doc));
-		if (omitted.length > 0) lines.push("", `> Module docs not loaded for this request (read on demand): ${omitted.map((doc) => `${pkg.relativeDirectory}/${doc.path}`).join(", ")}`);
+		if (omitted.length > 0) lines.push("", `> Module docs not loaded for this request (read on demand): ${omitted.map((doc) => packageRelativePath(pkg, doc.path)).join(", ")}`);
 	}
 	lines.push("");
 	return lines.join("\n");
@@ -1099,6 +1834,6 @@ function sortJson(value) {
 	return value;
 }
 //#endregion
-export { checkKnowledgeFreshnessFromIndex as a, renderKnowledgeIndexMarkdown as c, checkKnowledgeFreshness as i, smrtArchitecture as l, buildKnowledgeIndex as n, diffKnowledgeIndex as o, buildReviewContext as r, renderFreshnessResult as s, buildArchitectureContext as t, smrtReview as u };
+export { checkKnowledgeFreshnessFromIndex as a, renderFreshnessResult as c, smrtReview as d, checkKnowledgeFreshness as i, renderKnowledgeIndexMarkdown as l, buildKnowledgeIndex as n, diffKnowledgeIndex as o, buildReviewContext as r, packageDocPaths as s, buildArchitectureContext as t, smrtArchitecture as u };
 
-//# sourceMappingURL=knowledge-BPbgCtVJ.js.map
+//# sourceMappingURL=knowledge-DUUhTM5u.js.map