@happyvertical/smrt-dev-mcp 0.47.1 → 0.47.2

package/dist/index.js

@@ -1,17 +1,21 @@
 #!/usr/bin/env node
-import { a as checkKnowledgeFreshness, f as smrtArchitecture, h as TOOLS, i as buildReviewContext, m as REVIEW_SKILL_NAME, n as buildKnowledgeIndex, o as checkKnowledgeFreshnessFromIndex, p as smrtReview, r as buildPackageSpecialistContext, s as compactContextResult, t as buildArchitectureContext } from "./knowledge-DmZ-7GO9.js";
+import { a as checkKnowledgeFreshness, f as smrtArchitecture, h as TOOLS, i as buildReviewContext, m as REVIEW_SKILL_NAME, n as buildKnowledgeIndex, o as checkKnowledgeFreshnessFromIndex, p as smrtReview, r as buildPackageSpecialistContext, s as compactContextResult, t as buildArchitectureContext } from "./knowledge-CY6sQzpj.js";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { ProtocolError, ProtocolErrorCode, Server } from "@modelcontextprotocol/server";
+import { ProtocolError, ProtocolErrorCode, Server, createMcpHandler } from "@modelcontextprotocol/server";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
-import { createHash } from "node:crypto";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { createServer as createServer$1 } from "node:http";
+import { localhostHostValidation, localhostOriginValidation, toNodeHandler } from "@modelcontextprotocol/node";
+import { ObjectRegistry, readDispatchHealth, readJobHealth, readMigrationStatus, readRecentChanges, readRegistryDrift, readScheduleHealth, snapshotRegistry } from "@happyvertical/smrt-core";
+import { discoverSmrtPackages, resolveManifestPath } from "@happyvertical/smrt-core/manifest/discover-smrt-packages";
+import { SchemaComparer } from "@happyvertical/smrt-core/migrations";
+import { getPackageConfig, loadConfig } from "@happyvertical/smrt-config";
+import { getDatabase } from "@happyvertical/sql";
 import { ManifestAdapter, OxcScanner } from "@happyvertical/smrt-scanner";
 import { access, readFile, readdir } from "node:fs/promises";
 import { ManifestGenerator } from "@happyvertical/smrt-core/scanner";
-import { readDispatchHealth, readJobHealth, readMigrationStatus, readRecentChanges, readRegistryDrift, readScheduleHealth } from "@happyvertical/smrt-core";
-import { getPackageConfig, loadConfig } from "@happyvertical/smrt-config";
-import { getDatabase } from "@happyvertical/sql";
 //#region src/agent-skills.ts
 var AGENT_SKILLS = [{
 	name: "smrt-code-review",
@@ -47,1402 +51,1835 @@ function resolvePackageRoot() {
 	return packageRoot;
 }
 //#endregion
-//#region src/tools/generate-smrt-class.ts
-var TYPE_MAPPING = {
-	text: {
-		tsType: "string",
-		defaultValue: "''"
-	},
-	integer: {
-		tsType: "number",
-		defaultValue: "0"
-	},
-	decimal: {
-		tsType: "number",
-		defaultValue: "0.0"
-	},
-	boolean: {
-		tsType: "boolean",
-		defaultValue: "false"
-	},
-	datetime: {
-		tsType: "Date",
-		defaultValue: "new Date()"
-	},
-	json: {
-		tsType: "any",
-		defaultValue: "{}"
-	}
-};
-async function generateSmrtClass(args) {
-	const { className, properties, relationships, baseClass, tableName, conflictColumns, tenantScoped, includeTenantIdField, includeApiConfig, includeMcpConfig, includeCliConfig, includeCompanionSnippets } = normalizeArgs(args);
-	const coreImports = /* @__PURE__ */ new Set([baseClass, "smrt"]);
-	if (needsFieldDecorator(properties)) coreImports.add("field");
-	for (const relationship of relationships) coreImports.add(relationship.type);
-	const imports = [`import { ${Array.from(coreImports).join(", ")} } from '@happyvertical/smrt-core';`];
-	if (tenantScoped) {
-		const tenancyImports = ["TenantScoped"];
-		if (includeTenantIdField) tenancyImports.push("tenantId");
-		imports.push(`import { ${tenancyImports.join(", ")} } from '@happyvertical/smrt-tenancy';`);
+//#region src/server-info.ts
+var SERVER_NAME = "smrt-dev-mcp";
+function readPackageVersion() {
+	try {
+		const packageJsonPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+		return typeof packageJson.version === "string" ? packageJson.version : "0.0.0";
+	} catch {
+		return "0.0.0";
 	}
-	const decoratorLines = [...tenantScoped ? [`@TenantScoped(${renderObjectLiteral({ ...tenantScoped })})`] : [], renderSmrtDecorator({
-		includeApiConfig,
-		includeMcpConfig,
-		includeCliConfig,
-		tableName,
-		conflictColumns
-	})];
-	const classMembers = [
-		...includeTenantIdField && tenantScoped ? [renderTenantIdField(tenantScoped)] : [],
-		...properties.map(renderProperty),
-		...relationships.map(renderRelationship)
-	].filter(Boolean);
-	const companionSnippets = includeCompanionSnippets ? `\n${renderCompanionSnippets(className, Boolean(tenantScoped))}` : "";
-	return `${imports.join("\n")}
-
-${decoratorLines.join("\n")}
-export class ${className} extends ${baseClass} {
-${classMembers.join("\n\n")}
-
-  constructor(options: any = {}) {
-    super(options);
-    Object.assign(this, options);
-  }
-}
-${companionSnippets}`;
-}
-function normalizeArgs(args) {
-	const template = args.template ?? "basic";
-	const templateDefaults = defaultsForTemplate(template);
-	const tenantScoped = args.tenantScoped === true ? templateDefaults.tenantScoped ?? { mode: "required" } : args.tenantScoped === false ? void 0 : args.tenantScoped ?? templateDefaults.tenantScoped;
-	return {
-		className: args.className,
-		properties: args.properties,
-		baseClass: args.baseClass ?? "SmrtObject",
-		template,
-		tableName: args.tableName ?? templateDefaults.tableName,
-		conflictColumns: args.conflictColumns ?? templateDefaults.conflictColumns ?? [],
-		tenantScoped: normalizeTenantScoped(tenantScoped),
-		includeTenantIdField: args.includeTenantIdField ?? templateDefaults.includeTenantIdField ?? Boolean(tenantScoped),
-		relationships: args.relationships ?? [],
-		includeApiConfig: args.includeApiConfig ?? true,
-		includeMcpConfig: args.includeMcpConfig ?? true,
-		includeCliConfig: args.includeCliConfig ?? true,
-		includeCompanionSnippets: args.includeCompanionSnippets ?? false
-	};
 }
-function defaultsForTemplate(template) {
-	switch (template) {
-		case "optional-catalog": return {
-			tenantScoped: { mode: "optional" },
-			includeTenantIdField: true,
-			conflictColumns: ["tenant_id", "slug"]
-		};
-		case "tenant-project-object": return {
-			tenantScoped: { mode: "required" },
-			includeTenantIdField: true
-		};
-		case "tenant-event-log-object": return {
-			tenantScoped: { mode: "optional" },
-			includeTenantIdField: true
-		};
-		case "global-catalog": return { conflictColumns: ["slug"] };
-		case "cross-package-reference":
-		case "basic": return {};
+var SERVER_VERSION = readPackageVersion();
+//#endregion
+//#region src/tools/runtime/boot.ts
+/**
+* Confined runtime bootstrap for the Level 2 observation plane (#1831).
+*
+* "Booting" here means registering *manifests* into the in-process
+* `ObjectRegistry` — the project's own `.smrt/manifest.json` (or built
+* `dist/manifest.json`) plus every installed SMRT package manifest that the
+* project's dependency tree resolves to. No project source is imported, no
+* module is executed, no database is touched. That confinement is the safety
+* boundary: an observing agent sees what the runtime *would* register, never
+* what arbitrary project code does on import.
+*
+* The registry is a process-global singleton, so a process boots once. There
+* is deliberately no re-boot tool; restart the process to observe a rebuilt
+* manifest.
+*/
+/** Provenance label for facts read from authored/installed manifests. */
+var DECLARED_PROVENANCE = "declared (manifest)";
+/** Project manifest candidates, most authoritative first. */
+var PROJECT_MANIFEST_CANDIDATES = [".smrt/manifest.json", "dist/manifest.json"];
+function relativePath(projectRoot, path) {
+	const rel = relative(projectRoot, path);
+	if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) return basename(path);
+	return rel.split(sep).join("/");
+}
+function readManifest(path) {
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf8"));
+		return parsed && typeof parsed === "object" ? parsed : null;
+	} catch {
+		return null;
 	}
 }
-function normalizeTenantScoped(value) {
-	if (!value) return void 0;
-	return {
-		mode: typeof value === "object" ? value.mode ?? "required" : "required",
-		field: typeof value === "object" ? value.field ?? "tenantId" : "tenantId",
-		autoFilter: typeof value === "object" ? value.autoFilter : void 0,
-		autoPopulate: typeof value === "object" ? value.autoPopulate : void 0,
-		allowSuperAdminBypass: typeof value === "object" ? value.allowSuperAdminBypass : void 0
-	};
-}
-function renderSmrtDecorator(options) {
-	const decoratorConfig = {};
-	if (options.tableName) decoratorConfig.tableName = options.tableName;
-	if (options.conflictColumns.length > 0) decoratorConfig.conflictColumns = options.conflictColumns;
-	if (options.includeApiConfig) decoratorConfig.api = {
-		include: [
-			"list",
-			"get",
-			"create",
-			"update"
-		],
-		exclude: ["delete"]
-	};
-	if (options.includeMcpConfig) decoratorConfig.mcp = { include: ["list", "get"] };
-	if (options.includeCliConfig) decoratorConfig.cli = true;
-	return Object.keys(decoratorConfig).length > 0 ? `@smrt(${JSON.stringify(decoratorConfig, null, 2)})` : "@smrt()";
-}
-function renderTenantIdField(tenantScoped) {
-	const nullable = tenantScoped.mode === "optional";
-	const field = tenantScoped.field ?? "tenantId";
-	return nullable ? `  @tenantId({ nullable: true })\n  ${field}: string | null = null;` : `  @tenantId()\n  ${field}: string = '';`;
+function registerManifest(manifest, fallbackPackageName) {
+	const manifestPackageName = typeof manifest.packageName === "string" && manifest.packageName ? manifest.packageName : fallbackPackageName ?? void 0;
+	let count = 0;
+	for (const [name, definition] of Object.entries(manifest.objects ?? {})) {
+		if (!definition || typeof definition !== "object") continue;
+		const ownPackage = definition.packageName;
+		ObjectRegistry.registerFromManifest(name, definition, typeof ownPackage === "string" && ownPackage ? ownPackage : manifestPackageName);
+		count += 1;
+	}
+	return count;
 }
-function renderProperty(prop) {
-	const mapping = TYPE_MAPPING[prop.type];
-	const nullable = prop.nullable === true;
-	const tsType = nullable ? `${mapping.tsType} | null` : mapping.tsType;
-	const defaultValue = prop.defaultValue !== void 0 ? renderLiteral(prop.defaultValue) : nullable ? "null" : mapping.defaultValue;
-	const fieldOptions = compactObject$1({
-		required: prop.required,
-		nullable: prop.nullable,
-		description: prop.description
-	});
-	return `${prop.description ? `  /** ${prop.description} */\n` : ""}${Object.keys(fieldOptions).length > 0 ? `  @field(${JSON.stringify(fieldOptions)})\n` : ""}  ${prop.name}: ${tsType} = ${defaultValue};`;
+var booted = null;
+var bootedProjectRoot = null;
+/**
+* The resolved root the process booted from. Consumers must relativize
+* paths against *this* root, never a per-request argument, or a caller could
+* widen the root (e.g. `/`) and read the layout back through "relative" paths.
+*/
+function getBootedProjectRoot() {
+	return bootedProjectRoot;
 }
-function renderRelationship(relationship) {
-	const options = compactObject$1({
-		required: relationship.required,
-		nullable: relationship.nullable,
-		description: relationship.description,
-		validate: relationship.validate,
-		foreignKey: relationship.foreignKey,
-		through: relationship.through,
-		sourceKey: relationship.sourceKey,
-		targetKey: relationship.targetKey
+/**
+* Boot the confined runtime once per process. A second call returns the
+* existing record without touching the registry.
+*/
+async function bootRuntime(options = {}) {
+	if (booted) return booted;
+	const projectRoot = resolve(options.projectRoot ?? process.cwd());
+	const diagnostics = [];
+	const manifests = [];
+	const projectManifestPath = PROJECT_MANIFEST_CANDIDATES.map((candidate) => join(projectRoot, candidate)).find((path) => existsSync(path));
+	const projectPackageName = readProjectPackageName(projectRoot);
+	if (!projectManifestPath) diagnostics.push({
+		severity: "warning",
+		code: "project_manifest_missing",
+		message: "No project manifest found (.smrt/manifest.json or dist/manifest.json); run the project build so the runtime manifest exists."
 	});
-	const args = [renderLiteral(relationship.related), ...Object.keys(options).length > 0 ? [JSON.stringify(options)] : []];
-	const decorator = `@${relationship.type}(${args.join(", ")})`;
-	const fieldType = relationship.type === "oneToMany" || relationship.type === "manyToMany" ? "unknown[]" : relationship.nullable ? "string | null" : "string";
-	const defaultValue = relationship.type === "oneToMany" || relationship.type === "manyToMany" ? "[]" : relationship.nullable ? "null" : "''";
-	return `  ${decorator}\n  ${relationship.name}: ${fieldType} = ${defaultValue};`;
-}
-function needsFieldDecorator(properties) {
-	return properties.some((property) => property.required !== void 0 || property.nullable !== void 0 || property.description !== void 0);
-}
-function renderCompanionSnippets(className, usesTenantScoped) {
-	return `/*
- * Package wiring:
- * - Export ${className} from the package entrypoint used by consumers.
- * - Import this module from any package registration file that eagerly loads objects.${usesTenantScoped ? `\n * - Ensure package.json declares "@happyvertical/smrt-tenancy".` : ""}
- */`;
-}
-function renderObjectLiteral(value) {
-	return JSON.stringify(compactObject$1(value), null, 2);
-}
-function renderLiteral(value) {
-	if (typeof value === "string") return JSON.stringify(value);
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	if (value === null) return "null";
-	return JSON.stringify(value, null, 2);
+	else {
+		const manifest = readManifest(projectManifestPath);
+		if (!manifest) diagnostics.push({
+			severity: "error",
+			code: "project_manifest_invalid",
+			message: `Project manifest at ${relativePath(projectRoot, projectManifestPath)} is not valid JSON.`
+		});
+		else manifests.push({
+			kind: "project",
+			packageName: typeof manifest.packageName === "string" ? manifest.packageName : projectPackageName,
+			path: relativePath(projectRoot, projectManifestPath),
+			objectCount: registerManifest(manifest, projectPackageName)
+		});
+	}
+	let dependencyNames = [];
+	try {
+		dependencyNames = discoverSmrtPackages({
+			baseDir: projectRoot,
+			noCache: true
+		});
+	} catch (error) {
+		diagnostics.push({
+			severity: "warning",
+			code: "dependency_discovery_failed",
+			message: `Installed SMRT package discovery failed: ${error instanceof Error ? error.message : "unknown error"}`
+		});
+	}
+	for (const dependency of dependencyNames.sort()) {
+		const manifestPath = resolveManifestPath(dependency, projectRoot);
+		if (!manifestPath) {
+			diagnostics.push({
+				severity: "info",
+				code: "dependency_manifest_missing",
+				message: `Installed SMRT package ${dependency} exposes no runtime manifest.`
+			});
+			continue;
+		}
+		const manifest = readManifest(manifestPath);
+		if (!manifest) {
+			diagnostics.push({
+				severity: "warning",
+				code: "dependency_manifest_invalid",
+				message: `Manifest for ${dependency} is not valid JSON.`
+			});
+			continue;
+		}
+		manifests.push({
+			kind: "dependency",
+			packageName: dependency,
+			path: relativePath(projectRoot, manifestPath),
+			objectCount: registerManifest(manifest, dependency)
+		});
+	}
+	bootedProjectRoot = projectRoot;
+	booted = {
+		provenance: DECLARED_PROVENANCE,
+		bootedAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString(),
+		projectName: projectPackageName ?? basename(projectRoot),
+		manifests,
+		objectCount: manifests.reduce((sum, m) => sum + m.objectCount, 0),
+		diagnostics
+	};
+	return booted;
 }
-function compactObject$1(value) {
-	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+function readProjectPackageName(projectRoot) {
+	try {
+		const parsed = JSON.parse(readFileSync(join(projectRoot, "package.json"), "utf8"));
+		return typeof parsed.name === "string" && parsed.name ? parsed.name : null;
+	} catch {
+		return null;
+	}
 }
 //#endregion
-//#region src/tools/introspect-project.ts
-var DEFAULT_MANIFEST_PATHS = [
-	".smrt/manifest.json",
-	"dist/manifest.json",
-	"src/manifest/manifest.json"
-];
-var SCAN_EXCLUDE = [
-	"**/node_modules/**",
-	"**/dist/**",
-	"**/build/**",
-	"**/.git/**",
-	"**/.smrt/**",
-	"**/*.d.ts",
-	"**/*.test.ts",
-	"**/*.spec.ts",
-	"**/__tests__/**"
-];
-var RELATIONSHIP_TYPES = /* @__PURE__ */ new Set([
-	"foreignKey",
-	"crossPackageRef",
-	"oneToMany",
-	"manyToMany"
-]);
+//#region src/tools/runtime/connection.ts
 /**
-* Response budget in characters. Generous enough that a 42-object summary never
-* truncates, while still capping a runaway payload instead of emitting one.
-*/
-var DEFAULT_MAX_CHARS = 5e4;
-var DEFAULT_MCP_OPERATIONS = [
-	"list",
-	"get",
-	"create",
-	"update",
-	"delete"
+* Optional read-only dev-database connection resolution for runtime
+* diagnostics tools (#1824).
+*
+* Resolution order per call:
+*   1. explicit `dbUrl`/`dbType` tool arguments
+*   2. `SMRT_DEV_DB_URL` environment variable
+*   3. the project's cosmiconfig CLI section (`getPackageConfig('cli', ...)`
+*      from `@happyvertical/smrt-config`) → `database.{type,url}`
+*
+* No configured connection → `db: null` with `source: 'none'`; callers return
+* a successful static-only envelope. A connection is always opened lazily per
+* call and closed in the caller's `finally` — nothing is cached across calls
+* and the server never holds a database handle.
+*
+* Sensitive handling: connection strings are never logged or echoed. Every
+* surfaced URL passes through {@link redactConnectionString}; driver errors
+* are surfaced only through {@link safeErrorMessage}, which strips anything
+* that looks like a credential-bearing URL.
+*/
+var RUNTIME_DATABASE_TYPES = [
+	"sqlite",
+	"postgres",
+	"duckdb"
 ];
-async function introspectProject(args) {
-	const { directory = process.cwd(), includeFields = true, includeRelationships = true, includeMethods = true, detail = "summary", maxChars = DEFAULT_MAX_CHARS } = args;
-	const projectPath = resolve(directory);
-	if (!await pathExists$1(projectPath)) return JSON.stringify({
-		projectPath,
-		manifestSource: "none",
-		objectCount: 0,
-		objects: [],
-		diagnostics: [{
-			severity: "warning",
-			message: `Project directory does not exist: ${projectPath}`
-		}]
-	}, null, 2);
-	const packageMetadata = await readPackageMetadata(projectPath);
-	const tenantScopes = await scanTenantScopes(projectPath);
-	const manifestResult = await loadManifestArtifact(projectPath, args.manifestPath) ?? await scanSourceManifest(projectPath, packageMetadata);
-	const entries = Object.entries(manifestResult.manifest.objects ?? {});
-	const objects = detail === "summary" ? entries.map(([manifestKey, object]) => summarizeObject({
-		manifestKey,
-		object,
-		projectPath,
-		tenantScope: tenantScopes.get(object.className)
-	})) : entries.map(([manifestKey, object]) => formatObject({
-		manifestKey,
-		object,
-		projectPath,
-		includeFields,
-		includeRelationships,
-		includeMethods,
-		tenantScope: tenantScopes.get(object.className)
-	}));
-	objects.sort((left, right) => left.className.localeCompare(right.className));
-	const { kept, omitted } = applyObjectBudget(objects, maxChars);
-	const output = {
-		projectPath,
-		manifestSource: manifestResult.source,
-		manifestPath: "path" in manifestResult ? relative(projectPath, manifestResult.path) : void 0,
-		packageName: manifestResult.manifest.packageName ?? packageMetadata.name ?? void 0,
-		packageVersion: manifestResult.manifest.packageVersion ?? packageMetadata.version ?? void 0,
-		detail,
-		objectCount: objects.length,
-		scannedFileCount: manifestResult.scannedFileCount,
-		parseTimeMs: manifestResult.parseTimeMs,
-		...omitted > 0 ? { truncated: {
-			returnedObjectCount: kept.length,
-			omittedObjectCount: omitted,
-			budgetChars: maxChars,
-			guidance: "The object list hit its character budget; metadata and diagnostics are still complete. Narrow the scan with `directory` (a single package), keep `detail: \"summary\"`, or raise `maxChars` deliberately. Object names are sorted alphabetically, so omitted objects are the alphabetical tail."
-		} } : {},
-		objects: kept,
-		diagnostics: manifestResult.diagnostics
-	};
-	return JSON.stringify(output, null, 2);
+function isRuntimeDatabaseType(value) {
+	return RUNTIME_DATABASE_TYPES.includes(value);
 }
 /**
-* Trims the object list to the character budget, always keeping at least one so
-* a caller sees the shape rather than an empty list.
+* Sensitive query-parameter names. Matching normalizes the key (lowercase,
+* `_`/`-` stripped), so camelCase (`authToken`, `accessToken`) and hyphen
+* variants (`api-key`) are masked exactly like their snake_case forms.
 */
-function applyObjectBudget(objects, maxChars) {
-	const kept = [];
-	let used = 0;
-	for (const object of objects) {
-		const size = JSON.stringify(object, null, 2).length + 2;
-		if (used + size > maxChars && kept.length > 0) break;
-		used += size;
-		kept.push(object);
-	}
-	return {
-		kept,
-		omitted: objects.length - kept.length
-	};
-}
-function summarizeObject({ manifestKey, object, projectPath, tenantScope }) {
-	const fields = Object.entries(object.fields ?? {});
-	const decoratorConfig = object.decoratorConfig ?? {};
-	return compactObject({
-		manifestKey,
-		className: object.className,
-		qualifiedName: object.qualifiedName,
-		filePath: sanitizePath$1(projectPath, object.filePath),
-		extends: object.extends,
-		collection: object.collection,
-		tableName: object.schema?.tableName ?? stringFromConfig(decoratorConfig.tableName) ?? object.collection,
-		tenantScope: tenantScope ?? normalizeTenantScopedConfig(decoratorConfig.tenantScoped),
-		fieldCount: fields.length,
-		relationships: fields.filter(([, field]) => RELATIONSHIP_TYPES.has(field.type)).map(([name, field]) => `${name} -> ${field.related ?? ""} (${field.type})`).join(", ") || void 0,
-		mcpOperations: mcpOperationsFromConfig(decoratorConfig.mcp)
-	});
+var SENSITIVE_QUERY_PARAMS = [
+	"access_token",
+	"apikey",
+	"api_key",
+	"auth",
+	"auth_token",
+	"connectionstring",
+	"connection_string",
+	"password",
+	"token"
+];
+function normalizeQueryParamName(key) {
+	return key.toLowerCase().replace(/[_-]/g, "");
 }
+var SENSITIVE_QUERY_PARAM_NAMES = new Set(SENSITIVE_QUERY_PARAMS.map(normalizeQueryParamName));
+var DEFAULT_CLI_DATABASE = { database: {
+	type: "sqlite",
+	url: ":memory:"
+} };
 /**
-* An omitted `mcp` config means full CRUD, not a closed surface — the same rule
-* the knowledge index applies.
+* Redact a connection string so it can be shown to an agent without leaking
+* credentials. Mirrors the CLI's `redactConnectionString` (which is CLI
+* private); patterned identically so dev-mcp never depends on the CLI.
+*
+* Query-parameter masking normalizes each key (lowercase, `_`/`-` stripped),
+* so camelCase forms such as Turso/libsql's `?authToken=` mask exactly like
+* their snake_case forms. A final regex pass also masks `key=value` pairs
+* embedded in free text (driver error messages often quote the URL); it treats
+* the start of the string, `?`, `&`, `,`, `(`, and whitespace as the
+* preceding boundary.
 */
-function mcpOperationsFromConfig(config) {
-	if (config === false) return [];
-	if (typeof config !== "object" || config === null || Array.isArray(config)) return [...DEFAULT_MCP_OPERATIONS];
-	const record = config;
-	const include = Array.isArray(record.include) ? record.include.filter((item) => typeof item === "string") : DEFAULT_MCP_OPERATIONS;
-	const exclude = new Set(Array.isArray(record.exclude) ? record.exclude.filter((item) => typeof item === "string") : []);
-	return include.filter((operation) => !exclude.has(operation));
-}
-async function loadManifestArtifact(projectPath, manifestPath) {
-	const candidates = manifestPath ? [resolve(projectPath, manifestPath)] : DEFAULT_MANIFEST_PATHS.map((candidate) => join(projectPath, candidate));
-	const diagnostics = [];
-	for (const candidate of candidates) {
-		if (!await pathExists$1(candidate)) continue;
-		try {
-			const parsed = JSON.parse(await readFile(candidate, "utf-8"));
-			if (isManifestLike(parsed)) return {
-				source: "manifest",
-				path: candidate,
-				manifest: parsed,
-				diagnostics
-			};
-			diagnostics.push({
-				severity: "warning",
-				filePath: candidate,
-				message: "Manifest artifact is present but does not contain objects."
-			});
-		} catch (error) {
-			diagnostics.push({
-				severity: "error",
-				filePath: candidate,
-				message: `Unable to parse manifest artifact: ${messageFromError(error)}`
-			});
-		}
+function redactConnectionString(value) {
+	let redacted = value;
+	try {
+		const url = new URL(value);
+		if (url.password) url.password = "***";
+		for (const key of [...url.searchParams.keys()]) if (SENSITIVE_QUERY_PARAM_NAMES.has(normalizeQueryParamName(key))) url.searchParams.set(key, "***");
+		redacted = url.toString();
+	} catch {
+		redacted = value.replace(/([a-z][a-z0-9+.-]*:\/\/[^:\s/@]+:)(?:[^@\s]|@(?=[^@\s]*@))+(@)/gi, "$1***$2");
 	}
-	return manifestPath ? {
-		source: "manifest",
-		path: resolve(projectPath, manifestPath),
-		manifest: { objects: {} },
-		diagnostics: [...diagnostics, {
-			severity: "warning",
-			filePath: resolve(projectPath, manifestPath),
-			message: "Requested manifest artifact was not found."
-		}]
-	} : void 0;
+	redacted = redacted.replace(/(?:[A-Za-z]:)?(?:[\\/][^\s\\/'"`]+)+[\\/]([^\s\\/'"`]+\.(?:db|sqlite3?|duckdb))/g, "…/$1");
+	return redacted.replace(/((?:^|[?&,(\s])([a-z][a-z0-9_-]{0,30})=)([^&,\s)]+)/gi, (match, prefix, key) => SENSITIVE_QUERY_PARAM_NAMES.has(normalizeQueryParamName(key)) ? `${prefix}***` : match);
 }
-async function scanSourceManifest(projectPath, packageMetadata) {
-	const { results, resolved } = await new OxcScanner({
-		cwd: projectPath,
-		include: [
-			"**/*.ts",
-			"**/*.tsx",
-			"**/*.js",
-			"**/*.jsx"
-		],
-		exclude: SCAN_EXCLUDE
-	}).scanAndResolve();
-	const manifest = new ManifestAdapter().toManifest(resolved.filter((classDef) => classDef.hasSmartDecorator), {
-		packageName: packageMetadata.name,
-		packageVersion: packageMetadata.version,
-		typeAliases: results.typeAliases
-	});
-	finalizeScannerManifest(manifest, packageMetadata);
-	return {
-		source: "scanner",
-		manifest,
-		diagnostics: results.errors.map(scanErrorToDiagnostic),
-		scannedFileCount: results.fileCount,
-		parseTimeMs: Math.round(results.totalParseTimeMs)
-	};
+/**
+* Build a safe, redacted error message for a database failure. Connection
+* strings and raw driver error objects are never surfaced verbatim.
+*/
+function safeErrorMessage(error) {
+	return redactConnectionString(error instanceof Error ? error.message : String(error ?? "unknown error"));
 }
-function finalizeScannerManifest(manifest, packageMetadata) {
-	const manifestGen = new ManifestGenerator();
-	const fullManifest = manifest;
-	withSuppressedConsoleLog(() => {
-		manifestGen.injectTenantScopedFields(fullManifest);
-		manifestGen.mergeInheritedFields(fullManifest);
-		manifestGen.generateValidationRules(fullManifest);
-		manifestGen.generateSchemas(fullManifest);
-		manifestGen.assertTenantScopedSchemaContract(fullManifest);
-		manifestGen.generateAgentManifests(fullManifest, packageMetadata.name, packageMetadata.json);
-	});
+/**
+* Normalize a type hint into an engine `getDatabase` accepts. Unknown values
+* throw a safe error (no URL is included) so the caller can surface a
+* diagnostic instead of silently opening the wrong adapter.
+*/
+function toRuntimeDatabaseType(value) {
+	const normalized = value.trim().toLowerCase();
+	if (isRuntimeDatabaseType(normalized)) return normalized;
+	throw new Error(`Unsupported runtime database type "${normalized}"; expected sqlite, postgres, or duckdb`);
 }
-function withSuppressedConsoleLog(callback) {
-	const originalLog = console.log;
-	console.log = () => void 0;
-	try {
-		return callback();
-	} finally {
-		console.log = originalLog;
-	}
-}
-function formatObject({ manifestKey, object, projectPath, includeFields, includeRelationships, includeMethods, tenantScope }) {
-	const fieldDetails = Object.entries(object.fields ?? {}).map(([name, field]) => ({
-		name,
-		type: field.type,
-		...field.required !== void 0 ? { required: field.required } : {},
-		...field.default !== void 0 ? { default: field.default } : {},
-		...field.related ? { related: field.related } : {},
-		...field.description ? { description: field.description } : {},
-		...field._meta ? { meta: field._meta } : {},
-		...field.transient !== void 0 ? { transient: field.transient } : {}
-	}));
-	const relationshipDetails = fieldDetails.filter((field) => RELATIONSHIP_TYPES.has(field.type)).map((field) => ({
-		field: field.name,
-		relatedClass: field.related ?? "",
-		type: field.type,
-		...field.meta ? { meta: field.meta } : {}
-	}));
-	const methodDetails = Object.entries(object.methods ?? {}).map(([name, method]) => ({
-		name: method.name ?? name,
-		isAsync: method.async === true,
-		isStatic: method.isStatic === true,
-		isPublic: method.isPublic !== false,
-		parameters: method.parameters ?? [],
-		returnType: method.returnType ?? "unknown",
-		...method.description ? { description: method.description } : {}
-	}));
-	const decoratorConfig = object.decoratorConfig ?? {};
-	const effectiveTenantScope = tenantScope ?? normalizeTenantScopedConfig(decoratorConfig.tenantScoped);
-	const schema = object.schema;
-	return compactObject({
-		manifestKey,
-		name: object.name,
-		className: object.className,
-		qualifiedName: object.qualifiedName,
-		filePath: sanitizePath$1(projectPath, object.filePath),
-		packageName: object.packageName,
-		packageVersion: object.packageVersion,
-		importPath: object.importPath,
-		modulePath: object.modulePath,
-		exportName: object.exportName,
-		collectionExportName: object.collectionExportName,
-		collection: object.collection,
-		extends: object.extends,
-		extendsTypeArg: object.extendsTypeArg,
-		tableName: schema?.tableName ?? stringFromConfig(decoratorConfig.tableName) ?? object.collection,
-		tableStrategy: stringFromConfig(decoratorConfig.tableStrategy) ?? "cti",
-		conflictColumns: arrayFromConfig(decoratorConfig.conflictColumns),
-		tenantScope: effectiveTenantScope,
-		decoratorConfig,
-		schema: schema ? {
-			tableName: schema.tableName,
-			columns: schema.columns,
-			indexes: schema.indexes ?? [],
-			version: schema.version
-		} : void 0,
-		indexes: schema?.indexes ?? [],
-		staticProperties: object.staticProperties,
-		validationRules: object.validationRules,
-		...includeFields && {
-			fields: fieldDetails.map((field) => `${field.name}: ${field.type}`).join(", "),
-			fieldDetails
-		},
-		...includeRelationships && relationshipDetails.length > 0 && {
-			relationships: relationshipDetails.map((relationship) => `${relationship.field} -> ${relationship.relatedClass} (${relationship.type})`).join(", "),
-			relationshipDetails
-		},
-		...includeMethods && methodDetails.length > 0 && {
-			methods: methodDetails.map((method) => `${method.isAsync ? "async " : ""}${method.name}()`).join(", "),
-			methodDetails
-		}
-	});
-}
-async function scanTenantScopes(projectPath) {
-	const files = await listSourceFiles$1(projectPath);
-	const scopes = /* @__PURE__ */ new Map();
-	await Promise.all(files.map(async (filePath) => {
-		const content = await readFile(filePath, "utf-8");
-		const classMatches = content.matchAll(/class\s+([A-Za-z_]\w*)\b/g);
-		for (const match of classMatches) {
-			const className = match[1];
-			if (!className || match.index === void 0) continue;
-			const prefix = content.slice(Math.max(0, match.index - 800), match.index);
-			const tenantMatch = Array.from(prefix.matchAll(/@TenantScoped\s*\(([\s\S]*?)\)/g)).at(-1);
-			if (!tenantMatch) continue;
-			scopes.set(className, {
-				source: "TenantScoped",
-				...parseTenantScopedOptions(tenantMatch[1])
-			});
-		}
-	}));
-	return scopes;
+/** Infer an engine hint from a URL scheme when no explicit type is given. */
+function inferDatabaseType(url, hint) {
+	if (hint && hint.trim().length > 0) return hint;
+	if (/^postgres(ql)?:/i.test(url)) return "postgres";
+	if (/^duckdb:/i.test(url)) return "duckdb";
+	return "sqlite";
 }
-async function listSourceFiles$1(projectPath) {
-	const files = [];
-	async function visit(dir) {
-		let entries;
-		try {
-			entries = await readdir(dir, { withFileTypes: true });
-		} catch {
-			return;
-		}
-		for (const entry of entries) {
-			const fullPath = join(dir, entry.name);
-			if (entry.isDirectory()) {
-				if ([
-					"node_modules",
-					"dist",
-					"build",
-					".git",
-					".smrt",
-					"__tests__"
-				].includes(entry.name) || entry.name.startsWith(".")) continue;
-				await visit(fullPath);
-				continue;
-			}
-			if (entry.isFile() && /\.(tsx?|jsx?)$/.test(entry.name) && !entry.name.endsWith(".d.ts") && !entry.name.endsWith(".test.ts") && !entry.name.endsWith(".spec.ts")) files.push(fullPath);
-		}
+/**
+* Resolve the dev-database connection for one tool call.
+*
+* Returns `db: null` (never throws) when no connection is configured; callers
+* must treat that as "no runtime database" and return a static-only envelope.
+* A thrown connect error is propagated to the caller, which converts it into
+* a diagnostic envelope — it must never reach the MCP transport.
+*/
+async function resolveRuntimeConnection(args = {}) {
+	const argUrl = args.dbUrl?.trim();
+	if (argUrl && argUrl !== ":memory:") {
+		const databaseType = toRuntimeDatabaseType(inferDatabaseType(argUrl, args.dbType));
+		return {
+			db: await getDatabaseInstance({
+				type: databaseType,
+				url: argUrl
+			}),
+			source: "argument",
+			displayUrl: redactConnectionString(argUrl),
+			databaseType
+		};
 	}
-	await visit(projectPath);
-	return files;
-}
-function parseTenantScopedOptions(raw) {
-	const mode = raw.match(/mode\s*:\s*['"`](required|optional)['"`]/)?.[1];
-	const field = raw.match(/field\s*:\s*['"`]([A-Za-z_]\w*)['"`]/)?.[1];
-	const allowSuperAdminBypass = raw.match(/allowSuperAdminBypass\s*:\s*(true|false)/)?.[1];
-	const autoFilter = raw.match(/autoFilter\s*:\s*(true|false)/)?.[1];
-	const autoPopulate = raw.match(/autoPopulate\s*:\s*(true|false)/)?.[1];
-	return compactObject({
-		mode: mode ?? "required",
-		field: field ?? "tenantId",
-		autoFilter: autoFilter === void 0 ? void 0 : autoFilter === "true",
-		autoPopulate: autoPopulate === void 0 ? void 0 : autoPopulate === "true",
-		allowSuperAdminBypass: allowSuperAdminBypass === void 0 ? void 0 : allowSuperAdminBypass === "true"
-	});
-}
-function normalizeTenantScopedConfig(tenantScoped) {
-	if (!tenantScoped) return void 0;
-	const options = typeof tenantScoped === "object" && !Array.isArray(tenantScoped) ? tenantScoped : {};
-	return {
-		source: "smrt",
-		mode: options.mode ?? "required",
-		field: options.field ?? "tenantId",
-		autoFilter: options.autoFilter ?? true,
-		autoPopulate: options.autoPopulate ?? true,
-		allowSuperAdminBypass: options.allowSuperAdminBypass ?? false
-	};
-}
-async function readPackageMetadata(projectPath) {
-	const packageJsonPath = join(projectPath, "package.json");
-	if (!await pathExists$1(packageJsonPath)) return {};
-	try {
-		const json = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+	const envUrl = process.env.SMRT_DEV_DB_URL?.trim();
+	if (envUrl && envUrl !== ":memory:") {
+		const databaseType = toRuntimeDatabaseType(inferDatabaseType(envUrl, args.dbType));
 		return {
-			name: typeof json.name === "string" ? json.name : void 0,
-			version: typeof json.version === "string" ? json.version : void 0,
-			json
+			db: await getDatabaseInstance({
+				type: databaseType,
+				url: envUrl
+			}),
+			source: "environment",
+			displayUrl: redactConnectionString(envUrl),
+			databaseType
+		};
+	}
+	const config = await loadCliDatabaseConfig();
+	const configUrl = config?.database?.url?.trim();
+	if (configUrl && configUrl !== ":memory:") {
+		const databaseType = toRuntimeDatabaseType(config.database?.type || inferDatabaseType(configUrl, args.dbType));
+		return {
+			db: await getDatabaseInstance({
+				type: databaseType,
+				url: configUrl
+			}),
+			source: "config",
+			displayUrl: redactConnectionString(configUrl),
+			databaseType
 		};
-	} catch {
-		return {};
 	}
+	return {
+		db: null,
+		source: "none",
+		displayUrl: "",
+		databaseType: null
+	};
 }
-async function pathExists$1(path) {
+async function loadCliDatabaseConfig() {
 	try {
-		await access(path);
-		return true;
+		await loadConfig();
+		const database = getPackageConfig("cli", DEFAULT_CLI_DATABASE).database;
+		if (database && typeof database.url === "string") return { database };
+		return {};
 	} catch {
-		return false;
+		return {};
 	}
 }
-function isManifestLike(value) {
-	return !!value && typeof value === "object" && !!value.objects && typeof value.objects === "object";
-}
-function scanErrorToDiagnostic(error) {
-	return {
-		severity: error.severity,
-		message: error.message,
-		filePath: error.filePath,
-		line: error.line,
-		column: error.column
-	};
+async function getDatabaseInstance(options) {
+	return getDatabase(options);
 }
-function sanitizePath$1(projectPath, filePath) {
-	const relativePath = relative(projectPath, isAbsolute(filePath) ? filePath : resolve(projectPath, filePath));
-	if (!relativePath.startsWith("..")) return relativePath || filePath;
-	return filePath;
+/**
+* Best-effort close of a resolved connection. Never throws; diagnostics must
+* not fail because cleanup hiccuped.
+*/
+async function closeRuntimeConnection(db) {
+	if (!db || typeof db !== "object") return;
+	const closeable = db;
+	const close = closeable.close ?? closeable.client?.end ?? closeable.client?.close;
+	if (typeof close !== "function") return;
+	try {
+		await close.call(closeable.close ? closeable : closeable.client);
+	} catch {}
 }
-function stringFromConfig(value) {
-	return typeof value === "string" ? value : void 0;
+//#endregion
+//#region src/tools/runtime/tools.ts
+/**
+* Runtime diagnostics tools (#1824): read-only views over a project's dev
+* database `_smrt_*` system tables, powered by the shared SELECT-only
+* system-diagnostics reader in `@happyvertical/smrt-core`.
+*
+* Contract:
+* - **Optional connection.** No configured connection returns a successful
+*   static-only envelope — the server always starts and static tools are
+*   unaffected. A live connection is opened lazily per call and closed in
+*   `finally`; nothing is cached across calls.
+* - **Read-only.** Every underlying statement is a bounded SELECT; the reader
+*   never selects sensitive columns (job payloads/results, schedule
+*   `agentConfig`/`methodArgs`, dispatch `payload`/`metadata`).
+* - **Provenance-labeled.** Live results carry `provenance: 'runtime (live DB)'`;
+*   static-only results carry `provenance: 'static'` — agents must never
+*   conflate runtime facts with declared/manifest facts.
+* - **Fail-safe.** A connect/read error becomes a diagnostic envelope; it must
+*   never reach the MCP transport and never includes raw driver text or URLs.
+*/
+/** Provenance labels separating runtime facts from static/declared facts. */
+var RUNTIME_PROVENANCE = "runtime (live DB)";
+var STATIC_PROVENANCE = "static";
+/**
+* Serialize resolve → read → close per connection target so overlapping tool
+* calls never close a shared cached handle out from under each other.
+*
+* `@happyvertical/sql`'s `getDatabase` returns a cached handle per URL (no
+* opt-out in its public API). `closeRuntimeConnection` only calls the handle's
+* own `close`/`end`, but the SDK wraps those so a close also evicts the handle
+* from its connection cache. Two concurrent diagnostics calls resolving the
+* same URL would therefore share one handle, with the first finisher closing
+* it mid-read for the second. A per-key promise chain keeps each call's
+* lifecycle private: every call resolves its own view of the connection,
+* performs its read, and only then closes — the next queued call re-resolves
+* a fresh handle.
+*
+* The key is a digest of the resolved target, never the raw URL, so a
+* credential-bearing connection string is not retained in this map.
+*/
+var runtimeReadQueues = /* @__PURE__ */ new Map();
+function connectionQueueKey(args) {
+	const target = args.dbUrl?.trim() || process.env.SMRT_DEV_DB_URL?.trim() || "cli.config";
+	return createHash("sha256").update(target).digest("hex");
+}
+async function enqueueRuntimeRead(key, operation) {
+	const run = (runtimeReadQueues.get(key) ?? Promise.resolve()).then(operation, operation);
+	const tail = run.catch(() => void 0);
+	runtimeReadQueues.set(key, tail);
+	tail.then(() => {
+		if (runtimeReadQueues.get(key) === tail) runtimeReadQueues.delete(key);
+	});
+	return run;
+}
+/**
+* Run one read against the optional runtime connection, mapping every outcome
+* to a successful MCP envelope:
+*
+* - no connection configured → static-only envelope (`connected: false`)
+* - connect failure → static envelope with a safe diagnostic
+* - read failure → connected envelope with a safe diagnostic
+* - success → live result under `provenance: 'runtime (live DB)'`; a
+*   category-unavailable reader result keeps its `available: false` data and
+*   surfaces its message as a diagnostic
+*/
+async function withRuntimeConnection(args, read, staticHint) {
+	return enqueueRuntimeRead(connectionQueueKey(args), () => runWithRuntimeConnection(args, read, staticHint));
+}
+async function runWithRuntimeConnection(args, read, staticHint) {
+	let resolved;
+	try {
+		resolved = await resolveRuntimeConnection(args);
+	} catch (error) {
+		return {
+			ok: true,
+			coverage: null,
+			diagnostics: [{
+				severity: "warning",
+				code: "runtime_connection_error",
+				message: safeErrorMessage(error)
+			}],
+			data: {
+				provenance: STATIC_PROVENANCE,
+				connected: false
+			}
+		};
+	}
+	if (!resolved.db) return {
+		ok: true,
+		coverage: null,
+		diagnostics: [{
+			severity: "info",
+			code: "runtime_connection_unavailable",
+			message: `No runtime dev database configured (set SMRT_DEV_DB_URL or cli.database); returning static-only result: ${staticHint}. Static tools are unaffected.`
+		}],
+		data: {
+			provenance: STATIC_PROVENANCE,
+			connected: false
+		}
+	};
+	const { db, source, displayUrl, databaseType } = resolved;
+	try {
+		const { data, diagnostics } = await read(db);
+		return {
+			ok: true,
+			coverage: null,
+			diagnostics,
+			data: {
+				provenance: RUNTIME_PROVENANCE,
+				connected: true,
+				connectionSource: source,
+				databaseType,
+				displayUrl,
+				...data
+			}
+		};
+	} catch (error) {
+		return {
+			ok: true,
+			coverage: null,
+			diagnostics: [{
+				severity: "warning",
+				code: "runtime_read_error",
+				message: safeErrorMessage(error)
+			}],
+			data: {
+				provenance: RUNTIME_PROVENANCE,
+				connected: true,
+				connectionSource: source,
+				databaseType,
+				displayUrl
+			}
+		};
+	} finally {
+		await closeRuntimeConnection(db);
+	}
+}
+/**
+* Stored error columns (`error_message`, `last_error`) are free text written
+* at failure time and routinely quote connection URLs or credentials. Every
+* string in a live result passes through {@link redactConnectionString}
+* before it reaches an MCP client; structure and non-string values are kept.
+*/
+function redactStrings(value) {
+	if (typeof value === "string") return redactConnectionString(value);
+	if (Array.isArray(value)) return value.map((item) => redactStrings(item));
+	if (value !== null && typeof value === "object") {
+		const out = {};
+		for (const [key, item] of Object.entries(value)) out[key] = redactStrings(item);
+		return out;
+	}
+	return value;
+}
+/** Convert a reader result into envelope data + diagnostics. */
+function toEnvelopeParts(rawResult) {
+	const result = redactStrings(rawResult);
+	if (result !== null && typeof result === "object" && "available" in result && result.available === false) {
+		const unavailable = result;
+		const { message, ...rest } = unavailable;
+		return {
+			data: rest,
+			diagnostics: [{
+				severity: unavailable.reason === "retired" ? "info" : "warning",
+				code: `category_unavailable_${String(unavailable.reason).replace(/-/g, "_")}`,
+				message: String(message)
+			}]
+		};
+	}
+	return {
+		data: result,
+		diagnostics: []
+	};
+}
+function readToParts(read) {
+	return read.then((result) => toEnvelopeParts(result));
+}
+async function runtimeMigrationStatus(args = {}) {
+	const { limit, ...connectionArgs } = args;
+	return withRuntimeConnection(connectionArgs, (db) => readToParts(readMigrationStatus(db, { limit })), "no migration status — the manifest still reports the declared schema");
+}
+async function runtimeJobHealth(args = {}) {
+	const { limit, ...connectionArgs } = args;
+	return withRuntimeConnection(connectionArgs, (db) => readToParts(readJobHealth(db, { limit })), "no job health snapshot — the manifest still reports declared job queues");
+}
+async function runtimeScheduleHealth(args = {}) {
+	const { limit, ...connectionArgs } = args;
+	return withRuntimeConnection(connectionArgs, (db) => readToParts(readScheduleHealth(db, { limit })), "no schedule health snapshot — the manifest still reports declared schedules");
+}
+async function runtimeDispatchHealth(args = {}) {
+	const { limit, ...connectionArgs } = args;
+	return withRuntimeConnection(connectionArgs, (db) => readToParts(readDispatchHealth(db, { limit })), "no dispatch health snapshot — the manifest still reports declared dispatch topology");
+}
+async function runtimeRecentChanges(args = {}) {
+	const { since, tables, tenantId, limit, ...connectionArgs } = args;
+	return withRuntimeConnection(connectionArgs, (db) => readToParts(readRecentChanges(db, {
+		since,
+		tables,
+		tenantId,
+		limit
+	})), "no recent changes — static knowledge artifacts are unchanged");
+}
+async function runtimeRegistryDrift(args = {}) {
+	return withRuntimeConnection(args, (db) => readToParts(readRegistryDrift(db)), "no registry drift report — _smrt_registry is retired; declared objects come from the manifest");
+}
+//#endregion
+//#region src/tools/runtime/observation.ts
+/**
+* Level 2 read-only observation tools over the booted runtime (#1831).
+*
+* Three facts planes, labelled separately in every envelope:
+* - `declared (manifest)`: what the confined boot registered ({@link bootRuntime});
+* - `booted (registry)`: the in-process `ObjectRegistry` projected through the
+*   sanitized {@link snapshotRegistry} DTO;
+* - `runtime (live DB)`: the optional read-only connection, reused from Level 1.
+*
+* Nothing here mutates: no writes, no `do()`, no generated CRUD, no project
+* code execution. `runtime-schema-diff` only *introspects* the live schema.
+*/
+/** Row budget for `runtime-schema-diff` change lists. */
+var SCHEMA_DIFF_CHANGE_LIMIT = 200;
+function bootDiagnostics(boot) {
+	return boot.diagnostics.filter((d) => d.severity !== "info").map((d) => ({
+		severity: d.severity === "error" ? "warning" : d.severity,
+		code: `boot_${d.code}`,
+		message: d.message
+	}));
+}
+function bootSummary(boot) {
+	return {
+		provenance: boot.provenance,
+		bootedAt: boot.bootedAt,
+		projectName: boot.projectName,
+		manifests: boot.manifests,
+		objectCount: boot.objectCount
+	};
+}
+/** `runtime-registry`: sanitized snapshot of the booted registry. */
+async function runtimeRegistry(args = {}) {
+	const boot = await bootRuntime({ projectRoot: args.projectPath });
+	const snapshot = snapshotRegistry({
+		projectRoot: getBootedProjectRoot() ?? void 0,
+		objects: args.objects,
+		detail: args.detail ?? Boolean(args.objects?.length)
+	});
+	return {
+		ok: true,
+		coverage: null,
+		diagnostics: bootDiagnostics(boot),
+		data: {
+			provenance: snapshot.provenance,
+			boot: bootSummary(boot),
+			snapshot
+		}
+	};
+}
+/** `runtime-object`: one object's sanitized definition plus its generated DDL. */
+async function runtimeObject(args) {
+	const boot = await bootRuntime({ projectRoot: args.projectPath });
+	const name = typeof args.name === "string" ? args.name.trim() : "";
+	const snapshot = snapshotRegistry({
+		projectRoot: getBootedProjectRoot() ?? void 0,
+		objects: name ? [name] : [],
+		detail: true
+	});
+	const diagnostics = bootDiagnostics(boot);
+	let object = snapshot.objects[0] ?? null;
+	if (snapshot.objects.length > 1) {
+		object = null;
+		diagnostics.push({
+			severity: "warning",
+			code: "object_ambiguous",
+			message: `${name} is registered by several packages; pass a qualified name: ${snapshot.objects.map((candidate) => candidate.qualifiedName ?? candidate.name).join(", ")}`
+		});
+	} else if (!object) diagnostics.push({
+		severity: "warning",
+		code: "object_not_found",
+		message: name ? `No booted object named ${name}; use runtime-registry to list names.` : "name is required."
+	});
+	let ddl = null;
+	if (object) try {
+		ddl = ObjectRegistry.getSchemaDDL(object.qualifiedName ?? object.name, args.engine) ?? null;
+	} catch (error) {
+		diagnostics.push({
+			severity: "warning",
+			code: "ddl_unavailable",
+			message: `Generated DDL unavailable: ${error instanceof Error ? error.message : "unknown error"}`
+		});
+	}
+	return {
+		ok: true,
+		coverage: null,
+		diagnostics,
+		data: {
+			provenance: snapshot.provenance,
+			boot: bootSummary(boot),
+			object,
+			ddl
+		}
+	};
+}
+/**
+* `runtime-schema-diff`: booted registry schemas versus the live database,
+* using the same comparer `db:diff`/`db:migrate` use. Introspection only —
+* drop/relax options are pinned off and nothing is executed.
+*/
+async function runtimeSchemaDiff(args = {}) {
+	const boot = await bootRuntime({ projectRoot: args.projectPath });
+	const envelope = await withRuntimeConnection(args, async (db) => {
+		const diff = await new SchemaComparer(db, {
+			includeDroppedTables: false,
+			includeDroppedColumns: false,
+			includeDroppedIndexes: false,
+			relaxColumns: false
+		}).compare(ObjectRegistry.getAllSchemasAsDefinitions());
+		const byType = {};
+		for (const change of diff.changes) {
+			const type = String(change.type ?? "unknown");
+			byType[type] = (byType[type] ?? 0) + 1;
+		}
+		return {
+			data: {
+				boot: bootSummary(boot),
+				hasChanges: diff.has_changes,
+				addedTables: diff.added_tables.map((t) => t.tableName),
+				droppedTables: diff.dropped_tables,
+				orphanTables: diff.orphan_tables ?? [],
+				changeCount: diff.changes.length,
+				changesByType: byType,
+				changes: diff.changes.slice(0, SCHEMA_DIFF_CHANGE_LIMIT),
+				truncated: diff.changes.length > SCHEMA_DIFF_CHANGE_LIMIT
+			},
+			diagnostics: []
+		};
+	}, "booted registry schemas only; connect a dev database to diff against live tables");
+	envelope.diagnostics = [...bootDiagnostics(boot), ...envelope.diagnostics];
+	return envelope;
+}
+//#endregion
+//#region src/http.ts
+/**
+* Standalone Level 2 runtime dev-plane host (#1831).
+*
+* Serves a *positive* read-only tool catalog over the stateless 2026-07-28
+* Streamable HTTP transport (#2147): `createMcpHandler` with `legacy: 'reject'`
+* and `maxSubscriptions: 0`, adapted to Node with `toNodeHandler`. No SSE,
+* no session header, no sticky routing.
+*
+* Security boundary (development only):
+* - binds loopback only; SDK localhost Host/Origin validation runs first;
+* - every request needs `Authorization: Bearer <token>` (constant-time
+*   compare) — from `SMRT_DEV_MCP_TOKEN` or minted per process;
+* - no authenticated principal exists here, so scope stays fail-closed
+*   global-only exactly as in Level 1;
+* - the catalog never includes generated CRUD, custom actions, `do()`, or
+*   tool-backed `is()`.
+*/
+/**
+* The complete Level 2 catalog. A tool is exposed over HTTP only if it is
+* named here; the static stdio catalog is deliberately not mounted.
+*/
+var RUNTIME_HTTP_TOOL_NAMES = [
+	"runtime-registry",
+	"runtime-object",
+	"runtime-schema-diff",
+	"migration-status",
+	"job-health",
+	"schedule-health",
+	"dispatch-health",
+	"recent-changes",
+	"registry-drift"
+];
+var RUNTIME_HTTP_HANDLERS = {
+	"runtime-registry": (args) => runtimeRegistry(args),
+	"runtime-object": (args) => runtimeObject(args),
+	"runtime-schema-diff": (args) => runtimeSchemaDiff(args),
+	"migration-status": (args) => runtimeMigrationStatus(args),
+	"job-health": (args) => runtimeJobHealth(args),
+	"schedule-health": (args) => runtimeScheduleHealth(args),
+	"dispatch-health": (args) => runtimeDispatchHealth(args),
+	"recent-changes": (args) => runtimeRecentChanges(args),
+	"registry-drift": (args) => runtimeRegistryDrift(args)
+};
+/** Catalog definitions for the HTTP plane, in catalog order. */
+function runtimeHttpTools() {
+	const names = new Set(RUNTIME_HTTP_TOOL_NAMES);
+	return TOOLS.filter((tool) => names.has(tool.name));
+}
+/**
+* Build a fresh protocol server per request (stateless transport contract).
+* `projectRoot` is fixed at host start; per-request `projectPath` arguments
+* are ignored so a client cannot re-point the booted process.
+*/
+function createRuntimeProtocolServer(projectRoot) {
+	const server = new Server({
+		name: `${SERVER_NAME}-runtime`,
+		version: SERVER_VERSION
+	}, { capabilities: { tools: {} } });
+	server.setRequestHandler("tools/list", async () => ({ tools: runtimeHttpTools() }));
+	server.setRequestHandler("tools/call", async (request) => {
+		const name = request.params.name;
+		const handler = RUNTIME_HTTP_HANDLERS[name];
+		if (typeof handler !== "function") throw new Error(`Unknown runtime tool: ${name}`);
+		const { projectPath: _ignored, ...args } = request.params.arguments ?? {};
+		const result = await handler({
+			...args,
+			projectPath: projectRoot
+		});
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}],
+			structuredContent: result
+		};
+	});
+	return server;
+}
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"127.0.0.1",
+	"localhost",
+	"::1"
+]);
+function bearerMatches(header, token) {
+	if (!header?.startsWith("Bearer ")) return false;
+	const presented = Buffer.from(header.slice(7));
+	const expected = Buffer.from(token);
+	return presented.length === expected.length && timingSafeEqual(presented, expected);
+}
+function deny(res, status, message) {
+	res.statusCode = status;
+	res.setHeader("content-type", "application/json");
+	if (status === 401) res.setHeader("www-authenticate", "Bearer realm=\"smrt-dev-mcp runtime\"");
+	res.end(JSON.stringify({ error: message }));
+}
+/** Start the Level 2 host. Boots the confined runtime before listening. */
+async function startRuntimeHttpHost(options = {}) {
+	const host = options.host ?? "127.0.0.1";
+	if (!LOOPBACK_HOSTS.has(host)) throw new Error("The runtime dev-plane binds loopback only (127.0.0.1, localhost, ::1).");
+	const path = options.path ?? "/mcp";
+	const token = options.token ?? process.env.SMRT_DEV_MCP_TOKEN?.trim() ?? randomBytes(24).toString("base64url");
+	if (!token) throw new Error("SMRT_DEV_MCP_TOKEN must not be empty.");
+	const projectRoot = options.projectRoot ?? process.cwd();
+	const boot = await bootRuntime({ projectRoot });
+	const mcp = toNodeHandler(createMcpHandler(() => createRuntimeProtocolServer(projectRoot), {
+		legacy: "reject",
+		maxSubscriptions: 0
+	}));
+	const hostGuard = localhostHostValidation();
+	const originGuard = localhostOriginValidation();
+	const httpServer = createServer$1((req, res) => {
+		if (!hostGuard(req, res)) return;
+		if (!originGuard(req, res)) return;
+		if (new URL(req.url ?? "/", "http://localhost").pathname !== path) {
+			deny(res, 404, "not found");
+			return;
+		}
+		if (!bearerMatches(req.headers.authorization, token)) {
+			deny(res, 401, "missing or invalid bearer token");
+			return;
+		}
+		mcp(req, res);
+	});
+	await new Promise((resolve, reject) => {
+		httpServer.once("error", reject);
+		httpServer.listen(options.port ?? 0, host, () => {
+			httpServer.off("error", reject);
+			resolve();
+		});
+	});
+	const address = httpServer.address();
+	return {
+		url: `http://${address.family === "IPv6" ? `[${address.address}]` : address.address}:${address.port}${path}`,
+		token,
+		boot,
+		close: () => new Promise((resolve, reject) => {
+			httpServer.closeAllConnections?.();
+			httpServer.close((error) => error ? reject(error) : resolve());
+		})
+	};
+}
+//#endregion
+//#region src/tools/generate-smrt-class.ts
+var TYPE_MAPPING = {
+	text: {
+		tsType: "string",
+		defaultValue: "''"
+	},
+	integer: {
+		tsType: "number",
+		defaultValue: "0"
+	},
+	decimal: {
+		tsType: "number",
+		defaultValue: "0.0"
+	},
+	boolean: {
+		tsType: "boolean",
+		defaultValue: "false"
+	},
+	datetime: {
+		tsType: "Date",
+		defaultValue: "new Date()"
+	},
+	json: {
+		tsType: "any",
+		defaultValue: "{}"
+	}
+};
+async function generateSmrtClass(args) {
+	const { className, properties, relationships, baseClass, tableName, conflictColumns, tenantScoped, includeTenantIdField, includeApiConfig, includeMcpConfig, includeCliConfig, includeCompanionSnippets } = normalizeArgs(args);
+	const coreImports = /* @__PURE__ */ new Set([baseClass, "smrt"]);
+	if (needsFieldDecorator(properties)) coreImports.add("field");
+	for (const relationship of relationships) coreImports.add(relationship.type);
+	const imports = [`import { ${Array.from(coreImports).join(", ")} } from '@happyvertical/smrt-core';`];
+	if (tenantScoped) {
+		const tenancyImports = ["TenantScoped"];
+		if (includeTenantIdField) tenancyImports.push("tenantId");
+		imports.push(`import { ${tenancyImports.join(", ")} } from '@happyvertical/smrt-tenancy';`);
+	}
+	const decoratorLines = [...tenantScoped ? [`@TenantScoped(${renderObjectLiteral({ ...tenantScoped })})`] : [], renderSmrtDecorator({
+		includeApiConfig,
+		includeMcpConfig,
+		includeCliConfig,
+		tableName,
+		conflictColumns
+	})];
+	const classMembers = [
+		...includeTenantIdField && tenantScoped ? [renderTenantIdField(tenantScoped)] : [],
+		...properties.map(renderProperty),
+		...relationships.map(renderRelationship)
+	].filter(Boolean);
+	const companionSnippets = includeCompanionSnippets ? `\n${renderCompanionSnippets(className, Boolean(tenantScoped))}` : "";
+	return `${imports.join("\n")}
+
+${decoratorLines.join("\n")}
+export class ${className} extends ${baseClass} {
+${classMembers.join("\n\n")}
+
+  constructor(options: any = {}) {
+    super(options);
+    Object.assign(this, options);
+  }
+}
+${companionSnippets}`;
+}
+function normalizeArgs(args) {
+	const template = args.template ?? "basic";
+	const templateDefaults = defaultsForTemplate(template);
+	const tenantScoped = args.tenantScoped === true ? templateDefaults.tenantScoped ?? { mode: "required" } : args.tenantScoped === false ? void 0 : args.tenantScoped ?? templateDefaults.tenantScoped;
+	return {
+		className: args.className,
+		properties: args.properties,
+		baseClass: args.baseClass ?? "SmrtObject",
+		template,
+		tableName: args.tableName ?? templateDefaults.tableName,
+		conflictColumns: args.conflictColumns ?? templateDefaults.conflictColumns ?? [],
+		tenantScoped: normalizeTenantScoped(tenantScoped),
+		includeTenantIdField: args.includeTenantIdField ?? templateDefaults.includeTenantIdField ?? Boolean(tenantScoped),
+		relationships: args.relationships ?? [],
+		includeApiConfig: args.includeApiConfig ?? true,
+		includeMcpConfig: args.includeMcpConfig ?? true,
+		includeCliConfig: args.includeCliConfig ?? true,
+		includeCompanionSnippets: args.includeCompanionSnippets ?? false
+	};
+}
+function defaultsForTemplate(template) {
+	switch (template) {
+		case "optional-catalog": return {
+			tenantScoped: { mode: "optional" },
+			includeTenantIdField: true,
+			conflictColumns: ["tenant_id", "slug"]
+		};
+		case "tenant-project-object": return {
+			tenantScoped: { mode: "required" },
+			includeTenantIdField: true
+		};
+		case "tenant-event-log-object": return {
+			tenantScoped: { mode: "optional" },
+			includeTenantIdField: true
+		};
+		case "global-catalog": return { conflictColumns: ["slug"] };
+		case "cross-package-reference":
+		case "basic": return {};
+	}
+}
+function normalizeTenantScoped(value) {
+	if (!value) return void 0;
+	return {
+		mode: typeof value === "object" ? value.mode ?? "required" : "required",
+		field: typeof value === "object" ? value.field ?? "tenantId" : "tenantId",
+		autoFilter: typeof value === "object" ? value.autoFilter : void 0,
+		autoPopulate: typeof value === "object" ? value.autoPopulate : void 0,
+		allowSuperAdminBypass: typeof value === "object" ? value.allowSuperAdminBypass : void 0
+	};
+}
+function renderSmrtDecorator(options) {
+	const decoratorConfig = {};
+	if (options.tableName) decoratorConfig.tableName = options.tableName;
+	if (options.conflictColumns.length > 0) decoratorConfig.conflictColumns = options.conflictColumns;
+	if (options.includeApiConfig) decoratorConfig.api = {
+		include: [
+			"list",
+			"get",
+			"create",
+			"update"
+		],
+		exclude: ["delete"]
+	};
+	if (options.includeMcpConfig) decoratorConfig.mcp = { include: ["list", "get"] };
+	if (options.includeCliConfig) decoratorConfig.cli = true;
+	return Object.keys(decoratorConfig).length > 0 ? `@smrt(${JSON.stringify(decoratorConfig, null, 2)})` : "@smrt()";
 }
-function arrayFromConfig(value) {
-	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : void 0;
+function renderTenantIdField(tenantScoped) {
+	const nullable = tenantScoped.mode === "optional";
+	const field = tenantScoped.field ?? "tenantId";
+	return nullable ? `  @tenantId({ nullable: true })\n  ${field}: string | null = null;` : `  @tenantId()\n  ${field}: string = '';`;
 }
-function compactObject(value) {
-	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+function renderProperty(prop) {
+	const mapping = TYPE_MAPPING[prop.type];
+	const nullable = prop.nullable === true;
+	const tsType = nullable ? `${mapping.tsType} | null` : mapping.tsType;
+	const defaultValue = prop.defaultValue !== void 0 ? renderLiteral(prop.defaultValue) : nullable ? "null" : mapping.defaultValue;
+	const fieldOptions = compactObject$1({
+		required: prop.required,
+		nullable: prop.nullable,
+		description: prop.description
+	});
+	return `${prop.description ? `  /** ${prop.description} */\n` : ""}${Object.keys(fieldOptions).length > 0 ? `  @field(${JSON.stringify(fieldOptions)})\n` : ""}  ${prop.name}: ${tsType} = ${defaultValue};`;
 }
-function messageFromError(error) {
-	return error instanceof Error ? error.message : String(error);
+function renderRelationship(relationship) {
+	const options = compactObject$1({
+		required: relationship.required,
+		nullable: relationship.nullable,
+		description: relationship.description,
+		validate: relationship.validate,
+		foreignKey: relationship.foreignKey,
+		through: relationship.through,
+		sourceKey: relationship.sourceKey,
+		targetKey: relationship.targetKey
+	});
+	const args = [renderLiteral(relationship.related), ...Object.keys(options).length > 0 ? [JSON.stringify(options)] : []];
+	const decorator = `@${relationship.type}(${args.join(", ")})`;
+	const fieldType = relationship.type === "oneToMany" || relationship.type === "manyToMany" ? "unknown[]" : relationship.nullable ? "string | null" : "string";
+	const defaultValue = relationship.type === "oneToMany" || relationship.type === "manyToMany" ? "[]" : relationship.nullable ? "null" : "''";
+	return `  ${decorator}\n  ${relationship.name}: ${fieldType} = ${defaultValue};`;
+}
+function needsFieldDecorator(properties) {
+	return properties.some((property) => property.required !== void 0 || property.nullable !== void 0 || property.description !== void 0);
+}
+function renderCompanionSnippets(className, usesTenantScoped) {
+	return `/*
+ * Package wiring:
+ * - Export ${className} from the package entrypoint used by consumers.
+ * - Import this module from any package registration file that eagerly loads objects.${usesTenantScoped ? `\n * - Ensure package.json declares "@happyvertical/smrt-tenancy".` : ""}
+ */`;
+}
+function renderObjectLiteral(value) {
+	return JSON.stringify(compactObject$1(value), null, 2);
+}
+function renderLiteral(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (value === null) return "null";
+	return JSON.stringify(value, null, 2);
+}
+function compactObject$1(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
 //#endregion
-//#region src/tools/review-smrt-project.ts
+//#region src/tools/introspect-project.ts
+var DEFAULT_MANIFEST_PATHS = [
+	".smrt/manifest.json",
+	"dist/manifest.json",
+	"src/manifest/manifest.json"
+];
+var SCAN_EXCLUDE = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/.git/**",
+	"**/.smrt/**",
+	"**/*.d.ts",
+	"**/*.test.ts",
+	"**/*.spec.ts",
+	"**/__tests__/**"
+];
+var RELATIONSHIP_TYPES = /* @__PURE__ */ new Set([
+	"foreignKey",
+	"crossPackageRef",
+	"oneToMany",
+	"manyToMany"
+]);
 /**
-* Ecosystem-aware downstream project review.
-* Advisory only: scans manifests and source files, then reports alignment risks.
+* Response budget in characters. Generous enough that a 42-object summary never
+* truncates, while still capping a runaway payload instead of emitting one.
 */
-var SOURCE_EXTENSIONS = /\.(tsx?|jsx?|svelte)$/;
-var SKIP_DIRS = /* @__PURE__ */ new Set([
-	"node_modules",
-	"dist",
-	"build",
-	".git",
-	".smrt",
-	".svelte-kit",
-	"coverage"
-]);
-var DEPENDENCY_SECTIONS = [
-	"dependencies",
-	"devDependencies",
-	"peerDependencies",
-	"optionalDependencies"
+var DEFAULT_MAX_CHARS = 5e4;
+var DEFAULT_MCP_OPERATIONS = [
+	"list",
+	"get",
+	"create",
+	"update",
+	"delete"
 ];
-var SMRT_PACKAGE_PREFIX = "@happyvertical/smrt-";
-var HAPPYVERTICAL_PACKAGE_PREFIX = "@happyvertical/";
-async function reviewSmrtProject(args) {
-	const projectPath = resolve(args.directory ?? args.rootDir ?? process.cwd());
-	if (!await pathExists(projectPath)) return JSON.stringify({
+async function introspectProject(args) {
+	const { directory = process.cwd(), includeFields = true, includeRelationships = true, includeMethods = true, detail = "summary", maxChars = DEFAULT_MAX_CHARS } = args;
+	const projectPath = resolve(directory);
+	if (!await pathExists$1(projectPath)) return JSON.stringify({
 		projectPath,
-		packageCount: 0,
-		packages: [],
-		findings: [],
-		summary: {
-			high: 0,
-			medium: 0,
-			low: 0
-		},
+		manifestSource: "none",
+		objectCount: 0,
+		objects: [],
 		diagnostics: [{
 			severity: "warning",
 			message: `Project directory does not exist: ${projectPath}`
 		}]
 	}, null, 2);
-	const packageContexts = await buildPackageContexts(projectPath);
-	const sourceFiles = await listSourceFiles(projectPath, packageContexts);
-	await attachSourceFiles(sourceFiles, packageContexts, projectPath);
-	const findings = limitFindings([
-		...findMissingHappyVerticalDependencies(packageContexts),
-		...findCustomManifestGeneration(sourceFiles, projectPath),
-		...findDirectStorageBypasses(sourceFiles, packageContexts, projectPath),
-		...findCustomHttpShells(sourceFiles, packageContexts, projectPath),
-		...findLocalAuthTenancy(sourceFiles, packageContexts, projectPath),
-		...findUiShellDrift(packageContexts, projectPath),
-		...findMissingManifestArtifacts(sourceFiles, packageContexts, projectPath)
-	], args.maxFindings);
-	const packages = packageContexts.map(packageInventory).sort((left, right) => left.path.localeCompare(right.path));
-	const summary = summarizeFindings(findings);
-	return JSON.stringify({
+	const packageMetadata = await readPackageMetadata(projectPath);
+	const tenantScopes = await scanTenantScopes(projectPath);
+	const manifestResult = await loadManifestArtifact(projectPath, args.manifestPath) ?? await scanSourceManifest(projectPath, packageMetadata);
+	const entries = Object.entries(manifestResult.manifest.objects ?? {});
+	const objects = detail === "summary" ? entries.map(([manifestKey, object]) => summarizeObject({
+		manifestKey,
+		object,
 		projectPath,
-		packageCount: packages.length,
-		packages,
-		findings: args.includeSourceEvidence === false ? findings.map(({ evidence: _evidence, ...finding }) => finding) : findings,
-		summary,
-		referenceChecks: [
-			"Prefer SMRT scanner/runtime manifests over custom manifest builders.",
-			"Prefer SvelteKit plus @happyvertical/smrt-svelte for app shells.",
-			"Prefer @happyvertical/sql and @happyvertical/files/assets/content over direct durable node:fs storage.",
-			"Prefer smrt-users, smrt-tenancy, and profile/audit packages over local static auth seams."
-		],
-		suggestedFollowUpIssues: findings.map((finding) => ({
-			title: finding.suggestedIssueTitle,
-			severity: finding.severity,
-			area: finding.area
-		}))
-	}, null, 2);
-}
-async function buildPackageContexts(projectPath) {
-	const packageJsonPaths = await listPackageJsonFiles(projectPath);
-	const contexts = await Promise.all(packageJsonPaths.map(async (packageJsonPath) => {
-		const json = JSON.parse(await readFile(packageJsonPath, "utf-8"));
-		const directory = dirname(packageJsonPath);
-		return {
-			directory,
-			relativePath: relative(projectPath, directory) || ".",
-			packageJsonPath,
-			json,
-			dependencies: collectDependencies(json),
-			scripts: isRecord$1(json.scripts) ? json.scripts : {},
-			imports: /* @__PURE__ */ new Map(),
-			sourceFiles: []
-		};
+		tenantScope: tenantScopes.get(object.className)
+	})) : entries.map(([manifestKey, object]) => formatObject({
+		manifestKey,
+		object,
+		projectPath,
+		includeFields,
+		includeRelationships,
+		includeMethods,
+		tenantScope: tenantScopes.get(object.className)
 	}));
-	if (contexts.length === 0) contexts.push({
-		directory: projectPath,
-		relativePath: ".",
-		packageJsonPath: join(projectPath, "package.json"),
-		json: {},
-		dependencies: /* @__PURE__ */ new Set(),
-		scripts: {},
-		imports: /* @__PURE__ */ new Map(),
-		sourceFiles: []
-	});
-	return contexts.sort((left, right) => left.directory.length - right.directory.length);
+	objects.sort((left, right) => left.className.localeCompare(right.className));
+	const { kept, omitted } = applyObjectBudget(objects, maxChars);
+	const output = {
+		projectPath,
+		manifestSource: manifestResult.source,
+		manifestPath: "path" in manifestResult ? relative(projectPath, manifestResult.path) : void 0,
+		packageName: manifestResult.manifest.packageName ?? packageMetadata.name ?? void 0,
+		packageVersion: manifestResult.manifest.packageVersion ?? packageMetadata.version ?? void 0,
+		detail,
+		objectCount: objects.length,
+		scannedFileCount: manifestResult.scannedFileCount,
+		parseTimeMs: manifestResult.parseTimeMs,
+		...omitted > 0 ? { truncated: {
+			returnedObjectCount: kept.length,
+			omittedObjectCount: omitted,
+			budgetChars: maxChars,
+			guidance: "The object list hit its character budget; metadata and diagnostics are still complete. Narrow the scan with `directory` (a single package), keep `detail: \"summary\"`, or raise `maxChars` deliberately. Object names are sorted alphabetically, so omitted objects are the alphabetical tail."
+		} } : {},
+		objects: kept,
+		diagnostics: manifestResult.diagnostics
+	};
+	return JSON.stringify(output, null, 2);
 }
-async function listPackageJsonFiles(projectPath) {
-	const files = [];
-	await visit(projectPath, async (filePath, entryName) => {
-		if (entryName === "package.json") files.push(filePath);
-	});
-	return files;
+/**
+* Trims the object list to the character budget, always keeping at least one so
+* a caller sees the shape rather than an empty list.
+*/
+function applyObjectBudget(objects, maxChars) {
+	const kept = [];
+	let used = 0;
+	for (const object of objects) {
+		const size = JSON.stringify(object, null, 2).length + 2;
+		if (used + size > maxChars && kept.length > 0) break;
+		used += size;
+		kept.push(object);
+	}
+	return {
+		kept,
+		omitted: objects.length - kept.length
+	};
 }
-async function listSourceFiles(projectPath, packages) {
-	const files = [];
-	await visit(projectPath, async (filePath, entryName) => {
-		if (!SOURCE_EXTENSIONS.test(entryName)) return;
-		if (entryName.endsWith(".d.ts") || entryName.endsWith(".test.ts") || entryName.endsWith(".spec.ts")) return;
-		const packageDir = findOwningPackage(filePath, packages).directory;
-		const content = await readFile(filePath, "utf-8");
-		files.push({
-			path: filePath,
-			packageDir,
-			content
-		});
+function summarizeObject({ manifestKey, object, projectPath, tenantScope }) {
+	const fields = Object.entries(object.fields ?? {});
+	const decoratorConfig = object.decoratorConfig ?? {};
+	return compactObject({
+		manifestKey,
+		className: object.className,
+		qualifiedName: object.qualifiedName,
+		filePath: sanitizePath$1(projectPath, object.filePath),
+		extends: object.extends,
+		collection: object.collection,
+		tableName: object.schema?.tableName ?? stringFromConfig(decoratorConfig.tableName) ?? object.collection,
+		tenantScope: tenantScope ?? normalizeTenantScopedConfig(decoratorConfig.tenantScoped),
+		fieldCount: fields.length,
+		relationships: fields.filter(([, field]) => RELATIONSHIP_TYPES.has(field.type)).map(([name, field]) => `${name} -> ${field.related ?? ""} (${field.type})`).join(", ") || void 0,
+		mcpOperations: mcpOperationsFromConfig(decoratorConfig.mcp)
 	});
-	return files;
 }
-async function attachSourceFiles(sourceFiles, packages, projectPath) {
-	for (const sourceFile of sourceFiles) {
-		const owner = packages.find((pkg) => pkg.directory === sourceFile.packageDir);
-		if (!owner) continue;
-		owner.sourceFiles.push(sourceFile);
-		for (const importedPackage of extractImports(sourceFile.content)) {
-			if (!importedPackage.startsWith(HAPPYVERTICAL_PACKAGE_PREFIX)) continue;
-			const evidence = {
-				filePath: relative(projectPath, sourceFile.path),
-				line: lineNumber(sourceFile.content, importedPackage),
-				detail: `Imports ${importedPackage}`
+/**
+* An omitted `mcp` config means full CRUD, not a closed surface — the same rule
+* the knowledge index applies.
+*/
+function mcpOperationsFromConfig(config) {
+	if (config === false) return [];
+	if (typeof config !== "object" || config === null || Array.isArray(config)) return [...DEFAULT_MCP_OPERATIONS];
+	const record = config;
+	const include = Array.isArray(record.include) ? record.include.filter((item) => typeof item === "string") : DEFAULT_MCP_OPERATIONS;
+	const exclude = new Set(Array.isArray(record.exclude) ? record.exclude.filter((item) => typeof item === "string") : []);
+	return include.filter((operation) => !exclude.has(operation));
+}
+async function loadManifestArtifact(projectPath, manifestPath) {
+	const candidates = manifestPath ? [resolve(projectPath, manifestPath)] : DEFAULT_MANIFEST_PATHS.map((candidate) => join(projectPath, candidate));
+	const diagnostics = [];
+	for (const candidate of candidates) {
+		if (!await pathExists$1(candidate)) continue;
+		try {
+			const parsed = JSON.parse(await readFile(candidate, "utf-8"));
+			if (isManifestLike(parsed)) return {
+				source: "manifest",
+				path: candidate,
+				manifest: parsed,
+				diagnostics
 			};
-			const existing = owner.imports.get(importedPackage) ?? [];
-			existing.push(evidence);
-			owner.imports.set(importedPackage, existing);
+			diagnostics.push({
+				severity: "warning",
+				filePath: candidate,
+				message: "Manifest artifact is present but does not contain objects."
+			});
+		} catch (error) {
+			diagnostics.push({
+				severity: "error",
+				filePath: candidate,
+				message: `Unable to parse manifest artifact: ${messageFromError(error)}`
+			});
 		}
 	}
+	return manifestPath ? {
+		source: "manifest",
+		path: resolve(projectPath, manifestPath),
+		manifest: { objects: {} },
+		diagnostics: [...diagnostics, {
+			severity: "warning",
+			filePath: resolve(projectPath, manifestPath),
+			message: "Requested manifest artifact was not found."
+		}]
+	} : void 0;
 }
-function findMissingHappyVerticalDependencies(packages) {
-	return packages.flatMap((pkg) => {
-		const ownName = typeof pkg.json.name === "string" ? pkg.json.name : void 0;
-		const missing = Array.from(pkg.imports.keys()).filter((importedPackage) => importedPackage !== ownName && !pkg.dependencies.has(importedPackage));
-		if (missing.length === 0) return [];
-		return [{
-			severity: missing.some((name) => name.startsWith(SMRT_PACKAGE_PREFIX)) ? "high" : "medium",
-			area: "dependencies",
-			code: "missing-happyvertical-dependencies",
-			title: `${packageLabel(pkg)} imports HappyVertical packages that package.json does not declare`,
-			evidence: missing.flatMap((name) => pkg.imports.get(name) ?? []),
-			recommendation: "Declare every imported @happyvertical package in the owning package manifest so downstream installs and generated knowledge stay reproducible.",
-			suggestedIssueTitle: `Declare missing HappyVertical dependencies in ${packageLabel(pkg)}`
-		}];
+async function scanSourceManifest(projectPath, packageMetadata) {
+	const { results, resolved } = await new OxcScanner({
+		cwd: projectPath,
+		include: [
+			"**/*.ts",
+			"**/*.tsx",
+			"**/*.js",
+			"**/*.jsx"
+		],
+		exclude: SCAN_EXCLUDE
+	}).scanAndResolve();
+	const manifest = new ManifestAdapter().toManifest(resolved.filter((classDef) => classDef.hasSmartDecorator), {
+		packageName: packageMetadata.name,
+		packageVersion: packageMetadata.version,
+		typeAliases: results.typeAliases
 	});
+	finalizeScannerManifest(manifest, packageMetadata);
+	return {
+		source: "scanner",
+		manifest,
+		diagnostics: results.errors.map(scanErrorToDiagnostic),
+		scannedFileCount: results.fileCount,
+		parseTimeMs: Math.round(results.totalParseTimeMs)
+	};
 }
-function findCustomManifestGeneration(sourceFiles, projectPath) {
-	return sourceFiles.filter((file) => /manifest\.json/.test(file.content) && /objects\s*:/.test(file.content) && /\b(writeFile|writeFileSync)\b/.test(file.content) && !/@happyvertical\/smrt-scanner/.test(file.content)).map((file) => ({
-		severity: "high",
-		area: "manifest",
-		code: "custom-object-manifest-generation",
-		title: "Custom SMRT object manifest generation detected",
-		evidence: [{
-			filePath: relative(projectPath, file.path),
-			line: lineNumber(file.content, "manifest.json"),
-			detail: "Writes a manifest.json object inventory outside the SMRT scanner/runtime path."
-		}],
-		recommendation: "Use the SMRT scanner/runtime manifest path so defaults, relationships, schemas, tenant fields, and cross-package references match framework behavior.",
-		suggestedIssueTitle: "Replace custom object manifest generation with SMRT scanner/runtime manifest generation"
-	}));
-}
-function findDirectStorageBypasses(sourceFiles, packages, projectPath) {
-	return sourceFiles.flatMap((file) => {
-		const owner = findOwningPackage(file.path, packages);
-		const usesFs = /from\s+['"](?:node:fs|node:fs\/promises|fs|fs\/promises)['"]|require\(['"](?:node:fs|node:fs\/promises|fs|fs\/promises)['"]\)/.test(file.content);
-		const writesDurableData = /\b(writeFile|appendFile|mkdir|rm|rename)\b/.test(file.content) && /(\.json|data|storage|persist|cache|db)/i.test(file.content);
-		const usesDirectSql = /from\s+['"](?:better-sqlite3|sqlite3|pg|mysql2?|knex|drizzle-orm)['"]/.test(file.content);
-		if ((!usesFs || !writesDurableData) && !usesDirectSql) return [];
-		if (owner.dependencies.has("@happyvertical/sql") || owner.dependencies.has("@happyvertical/files") || owner.dependencies.has("@happyvertical/smrt-assets") || owner.dependencies.has("@happyvertical/smrt-content")) return [];
-		return [{
-			severity: "medium",
-			area: "storage",
-			code: "direct-storage-bypass",
-			title: `${packageLabel(owner)} appears to bypass HappyVertical storage packages`,
-			evidence: [{
-				filePath: relative(projectPath, file.path),
-				line: lineNumber(file.content, usesDirectSql ? "sqlite" : "writeFile"),
-				detail: usesDirectSql ? "Imports a direct SQL/storage library without @happyvertical/sql." : "Uses node:fs-style durable writes without @happyvertical/files/assets/content."
-			}],
-			recommendation: "Route durable data through @happyvertical/sql, @happyvertical/files, SMRT assets, or SMRT content unless this is explicitly build-only tooling.",
-			suggestedIssueTitle: `Review direct storage usage in ${packageLabel(owner)}`
-		}];
+function finalizeScannerManifest(manifest, packageMetadata) {
+	const manifestGen = new ManifestGenerator();
+	const fullManifest = manifest;
+	withSuppressedConsoleLog(() => {
+		manifestGen.injectTenantScopedFields(fullManifest);
+		manifestGen.mergeInheritedFields(fullManifest);
+		manifestGen.generateValidationRules(fullManifest);
+		manifestGen.generateSchemas(fullManifest);
+		manifestGen.assertTenantScopedSchemaContract(fullManifest);
+		manifestGen.generateAgentManifests(fullManifest, packageMetadata.name, packageMetadata.json);
 	});
 }
-function findCustomHttpShells(sourceFiles, packages, projectPath) {
-	const evidenceByPackage = /* @__PURE__ */ new Map();
-	for (const pkg of packages) {
-		if (pkg.dependencies.has("@sveltejs/kit")) continue;
-		const routerDependencies = [
-			"express",
-			"fastify",
-			"hono",
-			"koa"
-		].filter((dep) => pkg.dependencies.has(dep));
-		if (routerDependencies.length === 0) continue;
-		appendEvidence(evidenceByPackage, pkg, {
-			filePath: relative(projectPath, pkg.packageJsonPath),
-			detail: `Declares custom router package(s): ${routerDependencies.join(", ")}.`
-		});
-	}
-	for (const file of sourceFiles) {
-		const owner = findOwningPackage(file.path, packages);
-		if (owner.dependencies.has("@sveltejs/kit")) continue;
-		if (!/from\s+['"](?:node:http|http|node:https|https)['"]|createServer\s*\(/.test(file.content)) continue;
-		appendEvidence(evidenceByPackage, owner, {
-			filePath: relative(projectPath, file.path),
-			line: lineNumber(file.content, "createServer"),
-			detail: "Custom HTTP routing found without the SvelteKit/SMRT app-shell dependency pattern."
-		});
+function withSuppressedConsoleLog(callback) {
+	const originalLog = console.log;
+	console.log = () => void 0;
+	try {
+		return callback();
+	} finally {
+		console.log = originalLog;
 	}
-	return Array.from(evidenceByPackage.entries()).map(([owner, evidence]) => ({
-		severity: "medium",
-		area: "api-shell",
-		code: "custom-http-shell",
-		title: `${packageLabel(owner)} uses a custom HTTP shell`,
-		evidence,
-		recommendation: "Compare the app shell against the Anytown/Ergot SvelteKit + SMRT shell pattern before adding custom HTTP infrastructure.",
-		suggestedIssueTitle: `Align ${packageLabel(owner)} app shell with SMRT/SvelteKit conventions`
+}
+function formatObject({ manifestKey, object, projectPath, includeFields, includeRelationships, includeMethods, tenantScope }) {
+	const fieldDetails = Object.entries(object.fields ?? {}).map(([name, field]) => ({
+		name,
+		type: field.type,
+		...field.required !== void 0 ? { required: field.required } : {},
+		...field.default !== void 0 ? { default: field.default } : {},
+		...field.related ? { related: field.related } : {},
+		...field.description ? { description: field.description } : {},
+		...field._meta ? { meta: field._meta } : {},
+		...field.transient !== void 0 ? { transient: field.transient } : {}
+	}));
+	const relationshipDetails = fieldDetails.filter((field) => RELATIONSHIP_TYPES.has(field.type)).map((field) => ({
+		field: field.name,
+		relatedClass: field.related ?? "",
+		type: field.type,
+		...field.meta ? { meta: field.meta } : {}
+	}));
+	const methodDetails = Object.entries(object.methods ?? {}).map(([name, method]) => ({
+		name: method.name ?? name,
+		isAsync: method.async === true,
+		isStatic: method.isStatic === true,
+		isPublic: method.isPublic !== false,
+		parameters: method.parameters ?? [],
+		returnType: method.returnType ?? "unknown",
+		...method.description ? { description: method.description } : {}
+	}));
+	const decoratorConfig = object.decoratorConfig ?? {};
+	const effectiveTenantScope = tenantScope ?? normalizeTenantScopedConfig(decoratorConfig.tenantScoped);
+	const schema = object.schema;
+	return compactObject({
+		manifestKey,
+		name: object.name,
+		className: object.className,
+		qualifiedName: object.qualifiedName,
+		filePath: sanitizePath$1(projectPath, object.filePath),
+		packageName: object.packageName,
+		packageVersion: object.packageVersion,
+		importPath: object.importPath,
+		modulePath: object.modulePath,
+		exportName: object.exportName,
+		collectionExportName: object.collectionExportName,
+		collection: object.collection,
+		extends: object.extends,
+		extendsTypeArg: object.extendsTypeArg,
+		tableName: schema?.tableName ?? stringFromConfig(decoratorConfig.tableName) ?? object.collection,
+		tableStrategy: stringFromConfig(decoratorConfig.tableStrategy) ?? "cti",
+		conflictColumns: arrayFromConfig(decoratorConfig.conflictColumns),
+		tenantScope: effectiveTenantScope,
+		decoratorConfig,
+		schema: schema ? {
+			tableName: schema.tableName,
+			columns: schema.columns,
+			indexes: schema.indexes ?? [],
+			version: schema.version
+		} : void 0,
+		indexes: schema?.indexes ?? [],
+		staticProperties: object.staticProperties,
+		validationRules: object.validationRules,
+		...includeFields && {
+			fields: fieldDetails.map((field) => `${field.name}: ${field.type}`).join(", "),
+			fieldDetails
+		},
+		...includeRelationships && relationshipDetails.length > 0 && {
+			relationships: relationshipDetails.map((relationship) => `${relationship.field} -> ${relationship.relatedClass} (${relationship.type})`).join(", "),
+			relationshipDetails
+		},
+		...includeMethods && methodDetails.length > 0 && {
+			methods: methodDetails.map((method) => `${method.isAsync ? "async " : ""}${method.name}()`).join(", "),
+			methodDetails
+		}
+	});
+}
+async function scanTenantScopes(projectPath) {
+	const files = await listSourceFiles$1(projectPath);
+	const scopes = /* @__PURE__ */ new Map();
+	await Promise.all(files.map(async (filePath) => {
+		const content = await readFile(filePath, "utf-8");
+		const classMatches = content.matchAll(/class\s+([A-Za-z_]\w*)\b/g);
+		for (const match of classMatches) {
+			const className = match[1];
+			if (!className || match.index === void 0) continue;
+			const prefix = content.slice(Math.max(0, match.index - 800), match.index);
+			const tenantMatch = Array.from(prefix.matchAll(/@TenantScoped\s*\(([\s\S]*?)\)/g)).at(-1);
+			if (!tenantMatch) continue;
+			scopes.set(className, {
+				source: "TenantScoped",
+				...parseTenantScopedOptions(tenantMatch[1])
+			});
+		}
 	}));
+	return scopes;
 }
-function appendEvidence(evidenceByPackage, pkg, evidence) {
-	const existing = evidenceByPackage.get(pkg);
-	if (existing) {
-		existing.push(evidence);
-		return;
+async function listSourceFiles$1(projectPath) {
+	const files = [];
+	async function visit(dir) {
+		let entries;
+		try {
+			entries = await readdir(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const fullPath = join(dir, entry.name);
+			if (entry.isDirectory()) {
+				if ([
+					"node_modules",
+					"dist",
+					"build",
+					".git",
+					".smrt",
+					"__tests__"
+				].includes(entry.name) || entry.name.startsWith(".")) continue;
+				await visit(fullPath);
+				continue;
+			}
+			if (entry.isFile() && /\.(tsx?|jsx?)$/.test(entry.name) && !entry.name.endsWith(".d.ts") && !entry.name.endsWith(".test.ts") && !entry.name.endsWith(".spec.ts")) files.push(fullPath);
+		}
 	}
-	evidenceByPackage.set(pkg, [evidence]);
-}
-function findLocalAuthTenancy(sourceFiles, packages, projectPath) {
-	return sourceFiles.flatMap((file) => {
-		const owner = findOwningPackage(file.path, packages);
-		const pathSignal = /(auth|tenant|audit|session|rbac|user)/i.test(file.path);
-		const codeSignal = /\b(tenantId|tenant|role|permission|session|auditLog|apiKey)\b/.test(file.content);
-		if (!pathSignal || !codeSignal) return [];
-		if (owner.dependencies.has("@happyvertical/smrt-users") || owner.dependencies.has("@happyvertical/smrt-tenancy") || owner.dependencies.has("@happyvertical/smrt-profiles")) return [];
-		return [{
-			severity: "medium",
-			area: "auth-tenancy",
-			code: "local-auth-tenancy",
-			title: `${packageLabel(owner)} contains local auth/tenancy/audit logic`,
-			evidence: [{
-				filePath: relative(projectPath, file.path),
-				line: lineNumber(file.content, "tenant"),
-				detail: "Auth, tenancy, session, role, or audit terminology appears without smrt-users/smrt-tenancy/smrt-profiles dependencies."
-			}],
-			recommendation: "Add explicit adapters to smrt-users, smrt-tenancy, and profile/audit models or document why this local implementation is intentionally isolated.",
-			suggestedIssueTitle: `Review auth and tenancy adapters in ${packageLabel(owner)}`
-		}];
-	});
+	await visit(projectPath);
+	return files;
 }
-function findUiShellDrift(packages, projectPath) {
-	return packages.flatMap((pkg) => {
-		if (!(pkg.sourceFiles.some((file) => file.path.endsWith(".svelte")) || /(?:web|ui|app|site|frontend)/i.test(packageLabel(pkg)) || pkg.dependencies.has("svelte") || pkg.dependencies.has("vite"))) return [];
-		if (pkg.dependencies.has("@happyvertical/smrt-svelte")) return [];
-		return [{
-			severity: "low",
-			area: "ui-shell",
-			code: "missing-smrt-svelte-shell",
-			title: `${packageLabel(pkg)} looks like UI work without @happyvertical/smrt-svelte`,
-			evidence: [{
-				filePath: relative(projectPath, pkg.packageJsonPath),
-				detail: "UI-facing package does not declare @happyvertical/smrt-svelte."
-			}],
-			recommendation: "Use @happyvertical/smrt-svelte and the SvelteKit shell pattern for downstream app UI unless this package is intentionally framework-agnostic.",
-			suggestedIssueTitle: `Check SMRT Svelte shell alignment for ${packageLabel(pkg)}`
-		}];
+function parseTenantScopedOptions(raw) {
+	const mode = raw.match(/mode\s*:\s*['"`](required|optional)['"`]/)?.[1];
+	const field = raw.match(/field\s*:\s*['"`]([A-Za-z_]\w*)['"`]/)?.[1];
+	const allowSuperAdminBypass = raw.match(/allowSuperAdminBypass\s*:\s*(true|false)/)?.[1];
+	const autoFilter = raw.match(/autoFilter\s*:\s*(true|false)/)?.[1];
+	const autoPopulate = raw.match(/autoPopulate\s*:\s*(true|false)/)?.[1];
+	return compactObject({
+		mode: mode ?? "required",
+		field: field ?? "tenantId",
+		autoFilter: autoFilter === void 0 ? void 0 : autoFilter === "true",
+		autoPopulate: autoPopulate === void 0 ? void 0 : autoPopulate === "true",
+		allowSuperAdminBypass: allowSuperAdminBypass === void 0 ? void 0 : allowSuperAdminBypass === "true"
 	});
 }
-function findMissingManifestArtifacts(sourceFiles, packages, projectPath) {
-	return packages.flatMap((pkg) => {
-		if (!pkg.sourceFiles.some((file) => /@smrt\s*\(/.test(file.content))) return [];
-		if (sourceFiles.some((file) => file.packageDir === pkg.directory && /@happyvertical\/smrt-scanner/.test(file.content)) || pathExistsSyncHint(join(pkg.directory, ".smrt", "manifest.json")) || pathExistsSyncHint(join(pkg.directory, "dist", "manifest.json"))) return [];
-		return [{
-			severity: "low",
-			area: "manifest",
-			code: "missing-generated-manifest-artifact",
-			title: `${packageLabel(pkg)} has @smrt objects but no generated manifest artifact was found`,
-			evidence: [{
-				filePath: relative(projectPath, pkg.packageJsonPath),
-				detail: "No .smrt/manifest.json or dist/manifest.json was visible during review."
-			}],
-			recommendation: "Run the package build/test manifest generation path and verify it uses the SMRT scanner/runtime manifest pipeline.",
-			suggestedIssueTitle: `Verify SMRT manifest generation for ${packageLabel(pkg)}`
-		}];
-	});
+function normalizeTenantScopedConfig(tenantScoped) {
+	if (!tenantScoped) return void 0;
+	const options = typeof tenantScoped === "object" && !Array.isArray(tenantScoped) ? tenantScoped : {};
+	return {
+		source: "smrt",
+		mode: options.mode ?? "required",
+		field: options.field ?? "tenantId",
+		autoFilter: options.autoFilter ?? true,
+		autoPopulate: options.autoPopulate ?? true,
+		allowSuperAdminBypass: options.allowSuperAdminBypass ?? false
+	};
 }
-async function visit(dir, onFile) {
-	let entries;
+async function readPackageMetadata(projectPath) {
+	const packageJsonPath = join(projectPath, "package.json");
+	if (!await pathExists$1(packageJsonPath)) return {};
 	try {
-		entries = await readdir(dir, { withFileTypes: true });
+		const json = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+		return {
+			name: typeof json.name === "string" ? json.name : void 0,
+			version: typeof json.version === "string" ? json.version : void 0,
+			json
+		};
 	} catch {
-		return;
-	}
-	for (const entry of entries) {
-		const fullPath = join(dir, entry.name);
-		if (entry.isDirectory()) {
-			if (SKIP_DIRS.has(entry.name)) continue;
-			await visit(fullPath, onFile);
-			continue;
-		}
-		if (entry.isFile()) await onFile(fullPath, entry.name);
-	}
-}
-function collectDependencies(packageJson) {
-	const dependencies = /* @__PURE__ */ new Set();
-	for (const sectionName of DEPENDENCY_SECTIONS) {
-		const section = packageJson[sectionName];
-		if (!isRecord$1(section)) continue;
-		for (const dependencyName of Object.keys(section)) dependencies.add(dependencyName);
-	}
-	return dependencies;
-}
-function extractImports(content) {
-	const imports = /* @__PURE__ */ new Set();
-	for (const pattern of [
-		/(?:import|export)\s+(?:type\s+)?(?:[^'"]+\s+from\s+)?['"]([^'"]+)['"]/g,
-		/\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
-		/\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g
-	]) for (const match of content.matchAll(pattern)) {
-		const imported = normalizePackageImport(match[1]);
-		if (imported) imports.add(imported);
+		return {};
 	}
-	return Array.from(imports);
 }
-function normalizePackageImport(value) {
-	if (!value || value.startsWith(".") || value.startsWith("/")) return void 0;
-	if (value.startsWith("@")) {
-		const [scope, name] = value.split("/");
-		return scope && name ? `${scope}/${name}` : value;
+async function pathExists$1(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
 	}
-	return value.split("/")[0];
 }
-function findOwningPackage(filePath, packages) {
-	const normalized = resolve(filePath);
-	return packages.filter((pkg) => normalized === pkg.directory || normalized.startsWith(`${pkg.directory}${sep}`)).sort((left, right) => right.directory.length - left.directory.length)[0] ?? packages[0];
+function isManifestLike(value) {
+	return !!value && typeof value === "object" && !!value.objects && typeof value.objects === "object";
 }
-function packageInventory(pkg) {
-	const declaredHappyVerticalDependencies = Array.from(pkg.dependencies).filter((dependency) => dependency.startsWith(HAPPYVERTICAL_PACKAGE_PREFIX)).sort();
-	const importedHappyVerticalPackages = Array.from(pkg.imports.keys()).sort();
-	const ownName = typeof pkg.json.name === "string" ? pkg.json.name : void 0;
+function scanErrorToDiagnostic(error) {
 	return {
-		name: packageLabel(pkg),
-		path: pkg.relativePath,
-		private: typeof pkg.json.private === "boolean" ? pkg.json.private : void 0,
-		scripts: Object.keys(pkg.scripts).sort(),
-		declaredHappyVerticalDependencies,
-		importedHappyVerticalPackages,
-		missingHappyVerticalDependencies: importedHappyVerticalPackages.filter((name) => name !== ownName && !pkg.dependencies.has(name)),
-		hasSvelteKit: pkg.dependencies.has("@sveltejs/kit"),
-		hasSmrtSvelte: pkg.dependencies.has("@happyvertical/smrt-svelte")
+		severity: error.severity,
+		message: error.message,
+		filePath: error.filePath,
+		line: error.line,
+		column: error.column
 	};
 }
-function summarizeFindings(findings) {
-	return findings.reduce((summary, finding) => {
-		summary[finding.severity]++;
-		return summary;
-	}, {
-		high: 0,
-		medium: 0,
-		low: 0
-	});
-}
-function limitFindings(findings, maxFindings) {
-	const sorted = findings.sort((left, right) => severityRank(left.severity) - severityRank(right.severity) || left.area.localeCompare(right.area) || left.title.localeCompare(right.title));
-	return maxFindings && maxFindings > 0 ? sorted.slice(0, maxFindings) : sorted;
-}
-function severityRank(severity) {
-	return severity === "high" ? 0 : severity === "medium" ? 1 : 2;
-}
-function packageLabel(pkg) {
-	return typeof pkg.json.name === "string" ? pkg.json.name : pkg.relativePath;
+function sanitizePath$1(projectPath, filePath) {
+	const relativePath = relative(projectPath, isAbsolute(filePath) ? filePath : resolve(projectPath, filePath));
+	if (!relativePath.startsWith("..")) return relativePath || filePath;
+	return filePath;
 }
-function lineNumber(content, needle) {
-	const index = content.indexOf(needle);
-	if (index < 0) return void 0;
-	return content.slice(0, index).split("\n").length;
+function stringFromConfig(value) {
+	return typeof value === "string" ? value : void 0;
 }
-function isRecord$1(value) {
-	return !!value && typeof value === "object" && !Array.isArray(value);
+function arrayFromConfig(value) {
+	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : void 0;
 }
-async function pathExists(path) {
-	try {
-		await access(path);
-		return true;
-	} catch {
-		return false;
-	}
+function compactObject(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
-function pathExistsSyncHint(path) {
-	return existsSync(path);
+function messageFromError(error) {
+	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
-//#region src/tools/runtime/connection.ts
+//#region src/tools/review-smrt-project.ts
 /**
-* Optional read-only dev-database connection resolution for runtime
-* diagnostics tools (#1824).
-*
-* Resolution order per call:
-*   1. explicit `dbUrl`/`dbType` tool arguments
-*   2. `SMRT_DEV_DB_URL` environment variable
-*   3. the project's cosmiconfig CLI section (`getPackageConfig('cli', ...)`
-*      from `@happyvertical/smrt-config`) → `database.{type,url}`
-*
-* No configured connection → `db: null` with `source: 'none'`; callers return
-* a successful static-only envelope. A connection is always opened lazily per
-* call and closed in the caller's `finally` — nothing is cached across calls
-* and the server never holds a database handle.
-*
-* Sensitive handling: connection strings are never logged or echoed. Every
-* surfaced URL passes through {@link redactConnectionString}; driver errors
-* are surfaced only through {@link safeErrorMessage}, which strips anything
-* that looks like a credential-bearing URL.
+* Ecosystem-aware downstream project review.
+* Advisory only: scans manifests and source files, then reports alignment risks.
 */
-var RUNTIME_DATABASE_TYPES = [
-	"sqlite",
-	"postgres",
-	"duckdb"
+var SOURCE_EXTENSIONS = /\.(tsx?|jsx?|svelte)$/;
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	".git",
+	".smrt",
+	".svelte-kit",
+	"coverage"
+]);
+var DEPENDENCY_SECTIONS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
 ];
-function isRuntimeDatabaseType(value) {
-	return RUNTIME_DATABASE_TYPES.includes(value);
+var SMRT_PACKAGE_PREFIX = "@happyvertical/smrt-";
+var HAPPYVERTICAL_PACKAGE_PREFIX = "@happyvertical/";
+async function reviewSmrtProject(args) {
+	const projectPath = resolve(args.directory ?? args.rootDir ?? process.cwd());
+	if (!await pathExists(projectPath)) return JSON.stringify({
+		projectPath,
+		packageCount: 0,
+		packages: [],
+		findings: [],
+		summary: {
+			high: 0,
+			medium: 0,
+			low: 0
+		},
+		diagnostics: [{
+			severity: "warning",
+			message: `Project directory does not exist: ${projectPath}`
+		}]
+	}, null, 2);
+	const packageContexts = await buildPackageContexts(projectPath);
+	const sourceFiles = await listSourceFiles(projectPath, packageContexts);
+	await attachSourceFiles(sourceFiles, packageContexts, projectPath);
+	const findings = limitFindings([
+		...findMissingHappyVerticalDependencies(packageContexts),
+		...findCustomManifestGeneration(sourceFiles, projectPath),
+		...findDirectStorageBypasses(sourceFiles, packageContexts, projectPath),
+		...findCustomHttpShells(sourceFiles, packageContexts, projectPath),
+		...findLocalAuthTenancy(sourceFiles, packageContexts, projectPath),
+		...findUiShellDrift(packageContexts, projectPath),
+		...findMissingManifestArtifacts(sourceFiles, packageContexts, projectPath)
+	], args.maxFindings);
+	const packages = packageContexts.map(packageInventory).sort((left, right) => left.path.localeCompare(right.path));
+	const summary = summarizeFindings(findings);
+	return JSON.stringify({
+		projectPath,
+		packageCount: packages.length,
+		packages,
+		findings: args.includeSourceEvidence === false ? findings.map(({ evidence: _evidence, ...finding }) => finding) : findings,
+		summary,
+		referenceChecks: [
+			"Prefer SMRT scanner/runtime manifests over custom manifest builders.",
+			"Prefer SvelteKit plus @happyvertical/smrt-svelte for app shells.",
+			"Prefer @happyvertical/sql and @happyvertical/files/assets/content over direct durable node:fs storage.",
+			"Prefer smrt-users, smrt-tenancy, and profile/audit packages over local static auth seams."
+		],
+		suggestedFollowUpIssues: findings.map((finding) => ({
+			title: finding.suggestedIssueTitle,
+			severity: finding.severity,
+			area: finding.area
+		}))
+	}, null, 2);
 }
-/**
-* Sensitive query-parameter names. Matching normalizes the key (lowercase,
-* `_`/`-` stripped), so camelCase (`authToken`, `accessToken`) and hyphen
-* variants (`api-key`) are masked exactly like their snake_case forms.
-*/
-var SENSITIVE_QUERY_PARAMS = [
-	"access_token",
-	"apikey",
-	"api_key",
-	"auth",
-	"auth_token",
-	"connectionstring",
-	"connection_string",
-	"password",
-	"token"
-];
-function normalizeQueryParamName(key) {
-	return key.toLowerCase().replace(/[_-]/g, "");
+async function buildPackageContexts(projectPath) {
+	const packageJsonPaths = await listPackageJsonFiles(projectPath);
+	const contexts = await Promise.all(packageJsonPaths.map(async (packageJsonPath) => {
+		const json = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+		const directory = dirname(packageJsonPath);
+		return {
+			directory,
+			relativePath: relative(projectPath, directory) || ".",
+			packageJsonPath,
+			json,
+			dependencies: collectDependencies(json),
+			scripts: isRecord$1(json.scripts) ? json.scripts : {},
+			imports: /* @__PURE__ */ new Map(),
+			sourceFiles: []
+		};
+	}));
+	if (contexts.length === 0) contexts.push({
+		directory: projectPath,
+		relativePath: ".",
+		packageJsonPath: join(projectPath, "package.json"),
+		json: {},
+		dependencies: /* @__PURE__ */ new Set(),
+		scripts: {},
+		imports: /* @__PURE__ */ new Map(),
+		sourceFiles: []
+	});
+	return contexts.sort((left, right) => left.directory.length - right.directory.length);
 }
-var SENSITIVE_QUERY_PARAM_NAMES = new Set(SENSITIVE_QUERY_PARAMS.map(normalizeQueryParamName));
-var DEFAULT_CLI_DATABASE = { database: {
-	type: "sqlite",
-	url: ":memory:"
-} };
-/**
-* Redact a connection string so it can be shown to an agent without leaking
-* credentials. Mirrors the CLI's `redactConnectionString` (which is CLI
-* private); patterned identically so dev-mcp never depends on the CLI.
-*
-* Query-parameter masking normalizes each key (lowercase, `_`/`-` stripped),
-* so camelCase forms such as Turso/libsql's `?authToken=` mask exactly like
-* their snake_case forms. A final regex pass also masks `key=value` pairs
-* embedded in free text (driver error messages often quote the URL); it treats
-* the start of the string, `?`, `&`, `,`, `(`, and whitespace as the
-* preceding boundary.
-*/
-function redactConnectionString(value) {
-	let redacted = value;
-	try {
-		const url = new URL(value);
-		if (url.password) url.password = "***";
-		for (const key of [...url.searchParams.keys()]) if (SENSITIVE_QUERY_PARAM_NAMES.has(normalizeQueryParamName(key))) url.searchParams.set(key, "***");
-		redacted = url.toString();
-	} catch {
-		redacted = value.replace(/([a-z][a-z0-9+.-]*:\/\/[^:\s/@]+:)(?:[^@\s]|@(?=[^@\s]*@))+(@)/gi, "$1***$2");
-	}
-	return redacted.replace(/((?:^|[?&,(\s])([a-z][a-z0-9_-]{0,30})=)([^&,\s)]+)/gi, (match, prefix, key) => SENSITIVE_QUERY_PARAM_NAMES.has(normalizeQueryParamName(key)) ? `${prefix}***` : match);
+async function listPackageJsonFiles(projectPath) {
+	const files = [];
+	await visit(projectPath, async (filePath, entryName) => {
+		if (entryName === "package.json") files.push(filePath);
+	});
+	return files;
 }
-/**
-* Build a safe, redacted error message for a database failure. Connection
-* strings and raw driver error objects are never surfaced verbatim.
-*/
-function safeErrorMessage(error) {
-	return redactConnectionString(error instanceof Error ? error.message : String(error ?? "unknown error"));
+async function listSourceFiles(projectPath, packages) {
+	const files = [];
+	await visit(projectPath, async (filePath, entryName) => {
+		if (!SOURCE_EXTENSIONS.test(entryName)) return;
+		if (entryName.endsWith(".d.ts") || entryName.endsWith(".test.ts") || entryName.endsWith(".spec.ts")) return;
+		const packageDir = findOwningPackage(filePath, packages).directory;
+		const content = await readFile(filePath, "utf-8");
+		files.push({
+			path: filePath,
+			packageDir,
+			content
+		});
+	});
+	return files;
 }
-/**
-* Normalize a type hint into an engine `getDatabase` accepts. Unknown values
-* throw a safe error (no URL is included) so the caller can surface a
-* diagnostic instead of silently opening the wrong adapter.
-*/
-function toRuntimeDatabaseType(value) {
-	const normalized = value.trim().toLowerCase();
-	if (isRuntimeDatabaseType(normalized)) return normalized;
-	throw new Error(`Unsupported runtime database type "${normalized}"; expected sqlite, postgres, or duckdb`);
+async function attachSourceFiles(sourceFiles, packages, projectPath) {
+	for (const sourceFile of sourceFiles) {
+		const owner = packages.find((pkg) => pkg.directory === sourceFile.packageDir);
+		if (!owner) continue;
+		owner.sourceFiles.push(sourceFile);
+		for (const importedPackage of extractImports(sourceFile.content)) {
+			if (!importedPackage.startsWith(HAPPYVERTICAL_PACKAGE_PREFIX)) continue;
+			const evidence = {
+				filePath: relative(projectPath, sourceFile.path),
+				line: lineNumber(sourceFile.content, importedPackage),
+				detail: `Imports ${importedPackage}`
+			};
+			const existing = owner.imports.get(importedPackage) ?? [];
+			existing.push(evidence);
+			owner.imports.set(importedPackage, existing);
+		}
+	}
+}
+function findMissingHappyVerticalDependencies(packages) {
+	return packages.flatMap((pkg) => {
+		const ownName = typeof pkg.json.name === "string" ? pkg.json.name : void 0;
+		const missing = Array.from(pkg.imports.keys()).filter((importedPackage) => importedPackage !== ownName && !pkg.dependencies.has(importedPackage));
+		if (missing.length === 0) return [];
+		return [{
+			severity: missing.some((name) => name.startsWith(SMRT_PACKAGE_PREFIX)) ? "high" : "medium",
+			area: "dependencies",
+			code: "missing-happyvertical-dependencies",
+			title: `${packageLabel(pkg)} imports HappyVertical packages that package.json does not declare`,
+			evidence: missing.flatMap((name) => pkg.imports.get(name) ?? []),
+			recommendation: "Declare every imported @happyvertical package in the owning package manifest so downstream installs and generated knowledge stay reproducible.",
+			suggestedIssueTitle: `Declare missing HappyVertical dependencies in ${packageLabel(pkg)}`
+		}];
+	});
 }
-/** Infer an engine hint from a URL scheme when no explicit type is given. */
-function inferDatabaseType(url, hint) {
-	if (hint && hint.trim().length > 0) return hint;
-	if (/^postgres(ql)?:/i.test(url)) return "postgres";
-	if (/^duckdb:/i.test(url)) return "duckdb";
-	return "sqlite";
+function findCustomManifestGeneration(sourceFiles, projectPath) {
+	return sourceFiles.filter((file) => /manifest\.json/.test(file.content) && /objects\s*:/.test(file.content) && /\b(writeFile|writeFileSync)\b/.test(file.content) && !/@happyvertical\/smrt-scanner/.test(file.content)).map((file) => ({
+		severity: "high",
+		area: "manifest",
+		code: "custom-object-manifest-generation",
+		title: "Custom SMRT object manifest generation detected",
+		evidence: [{
+			filePath: relative(projectPath, file.path),
+			line: lineNumber(file.content, "manifest.json"),
+			detail: "Writes a manifest.json object inventory outside the SMRT scanner/runtime path."
+		}],
+		recommendation: "Use the SMRT scanner/runtime manifest path so defaults, relationships, schemas, tenant fields, and cross-package references match framework behavior.",
+		suggestedIssueTitle: "Replace custom object manifest generation with SMRT scanner/runtime manifest generation"
+	}));
 }
-/**
-* Resolve the dev-database connection for one tool call.
-*
-* Returns `db: null` (never throws) when no connection is configured; callers
-* must treat that as "no runtime database" and return a static-only envelope.
-* A thrown connect error is propagated to the caller, which converts it into
-* a diagnostic envelope — it must never reach the MCP transport.
-*/
-async function resolveRuntimeConnection(args = {}) {
-	const argUrl = args.dbUrl?.trim();
-	if (argUrl && argUrl !== ":memory:") {
-		const databaseType = toRuntimeDatabaseType(inferDatabaseType(argUrl, args.dbType));
-		return {
-			db: await getDatabaseInstance({
-				type: databaseType,
-				url: argUrl
-			}),
-			source: "argument",
-			displayUrl: redactConnectionString(argUrl),
-			databaseType
-		};
-	}
-	const envUrl = process.env.SMRT_DEV_DB_URL?.trim();
-	if (envUrl && envUrl !== ":memory:") {
-		const databaseType = toRuntimeDatabaseType(inferDatabaseType(envUrl, args.dbType));
-		return {
-			db: await getDatabaseInstance({
-				type: databaseType,
-				url: envUrl
-			}),
-			source: "environment",
-			displayUrl: redactConnectionString(envUrl),
-			databaseType
-		};
+function findDirectStorageBypasses(sourceFiles, packages, projectPath) {
+	return sourceFiles.flatMap((file) => {
+		const owner = findOwningPackage(file.path, packages);
+		const usesFs = /from\s+['"](?:node:fs|node:fs\/promises|fs|fs\/promises)['"]|require\(['"](?:node:fs|node:fs\/promises|fs|fs\/promises)['"]\)/.test(file.content);
+		const writesDurableData = /\b(writeFile|appendFile|mkdir|rm|rename)\b/.test(file.content) && /(\.json|data|storage|persist|cache|db)/i.test(file.content);
+		const usesDirectSql = /from\s+['"](?:better-sqlite3|sqlite3|pg|mysql2?|knex|drizzle-orm)['"]/.test(file.content);
+		if ((!usesFs || !writesDurableData) && !usesDirectSql) return [];
+		if (owner.dependencies.has("@happyvertical/sql") || owner.dependencies.has("@happyvertical/files") || owner.dependencies.has("@happyvertical/smrt-assets") || owner.dependencies.has("@happyvertical/smrt-content")) return [];
+		return [{
+			severity: "medium",
+			area: "storage",
+			code: "direct-storage-bypass",
+			title: `${packageLabel(owner)} appears to bypass HappyVertical storage packages`,
+			evidence: [{
+				filePath: relative(projectPath, file.path),
+				line: lineNumber(file.content, usesDirectSql ? "sqlite" : "writeFile"),
+				detail: usesDirectSql ? "Imports a direct SQL/storage library without @happyvertical/sql." : "Uses node:fs-style durable writes without @happyvertical/files/assets/content."
+			}],
+			recommendation: "Route durable data through @happyvertical/sql, @happyvertical/files, SMRT assets, or SMRT content unless this is explicitly build-only tooling.",
+			suggestedIssueTitle: `Review direct storage usage in ${packageLabel(owner)}`
+		}];
+	});
+}
+function findCustomHttpShells(sourceFiles, packages, projectPath) {
+	const evidenceByPackage = /* @__PURE__ */ new Map();
+	for (const pkg of packages) {
+		if (pkg.dependencies.has("@sveltejs/kit")) continue;
+		const routerDependencies = [
+			"express",
+			"fastify",
+			"hono",
+			"koa"
+		].filter((dep) => pkg.dependencies.has(dep));
+		if (routerDependencies.length === 0) continue;
+		appendEvidence(evidenceByPackage, pkg, {
+			filePath: relative(projectPath, pkg.packageJsonPath),
+			detail: `Declares custom router package(s): ${routerDependencies.join(", ")}.`
+		});
 	}
-	const config = await loadCliDatabaseConfig();
-	const configUrl = config?.database?.url?.trim();
-	if (configUrl && configUrl !== ":memory:") {
-		const databaseType = toRuntimeDatabaseType(config.database?.type || inferDatabaseType(configUrl, args.dbType));
-		return {
-			db: await getDatabaseInstance({
-				type: databaseType,
-				url: configUrl
-			}),
-			source: "config",
-			displayUrl: redactConnectionString(configUrl),
-			databaseType
-		};
+	for (const file of sourceFiles) {
+		const owner = findOwningPackage(file.path, packages);
+		if (owner.dependencies.has("@sveltejs/kit")) continue;
+		if (!/from\s+['"](?:node:http|http|node:https|https)['"]|createServer\s*\(/.test(file.content)) continue;
+		appendEvidence(evidenceByPackage, owner, {
+			filePath: relative(projectPath, file.path),
+			line: lineNumber(file.content, "createServer"),
+			detail: "Custom HTTP routing found without the SvelteKit/SMRT app-shell dependency pattern."
+		});
 	}
-	return {
-		db: null,
-		source: "none",
-		displayUrl: "",
-		databaseType: null
-	};
+	return Array.from(evidenceByPackage.entries()).map(([owner, evidence]) => ({
+		severity: "medium",
+		area: "api-shell",
+		code: "custom-http-shell",
+		title: `${packageLabel(owner)} uses a custom HTTP shell`,
+		evidence,
+		recommendation: "Compare the app shell against the Anytown/Ergot SvelteKit + SMRT shell pattern before adding custom HTTP infrastructure.",
+		suggestedIssueTitle: `Align ${packageLabel(owner)} app shell with SMRT/SvelteKit conventions`
+	}));
 }
-async function loadCliDatabaseConfig() {
-	try {
-		await loadConfig();
-		const database = getPackageConfig("cli", DEFAULT_CLI_DATABASE).database;
-		if (database && typeof database.url === "string") return { database };
-		return {};
-	} catch {
-		return {};
+function appendEvidence(evidenceByPackage, pkg, evidence) {
+	const existing = evidenceByPackage.get(pkg);
+	if (existing) {
+		existing.push(evidence);
+		return;
 	}
+	evidenceByPackage.set(pkg, [evidence]);
 }
-async function getDatabaseInstance(options) {
-	return getDatabase(options);
-}
-/**
-* Best-effort close of a resolved connection. Never throws; diagnostics must
-* not fail because cleanup hiccuped.
-*/
-async function closeRuntimeConnection(db) {
-	if (!db || typeof db !== "object") return;
-	const closeable = db;
-	const close = closeable.close ?? closeable.client?.end ?? closeable.client?.close;
-	if (typeof close !== "function") return;
-	try {
-		await close.call(closeable.close ? closeable : closeable.client);
-	} catch {}
+function findLocalAuthTenancy(sourceFiles, packages, projectPath) {
+	return sourceFiles.flatMap((file) => {
+		const owner = findOwningPackage(file.path, packages);
+		const pathSignal = /(auth|tenant|audit|session|rbac|user)/i.test(file.path);
+		const codeSignal = /\b(tenantId|tenant|role|permission|session|auditLog|apiKey)\b/.test(file.content);
+		if (!pathSignal || !codeSignal) return [];
+		if (owner.dependencies.has("@happyvertical/smrt-users") || owner.dependencies.has("@happyvertical/smrt-tenancy") || owner.dependencies.has("@happyvertical/smrt-profiles")) return [];
+		return [{
+			severity: "medium",
+			area: "auth-tenancy",
+			code: "local-auth-tenancy",
+			title: `${packageLabel(owner)} contains local auth/tenancy/audit logic`,
+			evidence: [{
+				filePath: relative(projectPath, file.path),
+				line: lineNumber(file.content, "tenant"),
+				detail: "Auth, tenancy, session, role, or audit terminology appears without smrt-users/smrt-tenancy/smrt-profiles dependencies."
+			}],
+			recommendation: "Add explicit adapters to smrt-users, smrt-tenancy, and profile/audit models or document why this local implementation is intentionally isolated.",
+			suggestedIssueTitle: `Review auth and tenancy adapters in ${packageLabel(owner)}`
+		}];
+	});
 }
-//#endregion
-//#region src/tools/runtime/tools.ts
-/**
-* Runtime diagnostics tools (#1824): read-only views over a project's dev
-* database `_smrt_*` system tables, powered by the shared SELECT-only
-* system-diagnostics reader in `@happyvertical/smrt-core`.
-*
-* Contract:
-* - **Optional connection.** No configured connection returns a successful
-*   static-only envelope — the server always starts and static tools are
-*   unaffected. A live connection is opened lazily per call and closed in
-*   `finally`; nothing is cached across calls.
-* - **Read-only.** Every underlying statement is a bounded SELECT; the reader
-*   never selects sensitive columns (job payloads/results, schedule
-*   `agentConfig`/`methodArgs`, dispatch `payload`/`metadata`).
-* - **Provenance-labeled.** Live results carry `provenance: 'runtime (live DB)'`;
-*   static-only results carry `provenance: 'static'` — agents must never
-*   conflate runtime facts with declared/manifest facts.
-* - **Fail-safe.** A connect/read error becomes a diagnostic envelope; it must
-*   never reach the MCP transport and never includes raw driver text or URLs.
-*/
-/** Provenance labels separating runtime facts from static/declared facts. */
-var RUNTIME_PROVENANCE = "runtime (live DB)";
-var STATIC_PROVENANCE = "static";
-/**
-* Serialize resolve → read → close per connection target so overlapping tool
-* calls never close a shared cached handle out from under each other.
-*
-* `@happyvertical/sql`'s `getDatabase` returns a cached handle per URL (no
-* opt-out in its public API). `closeRuntimeConnection` only calls the handle's
-* own `close`/`end`, but the SDK wraps those so a close also evicts the handle
-* from its connection cache. Two concurrent diagnostics calls resolving the
-* same URL would therefore share one handle, with the first finisher closing
-* it mid-read for the second. A per-key promise chain keeps each call's
-* lifecycle private: every call resolves its own view of the connection,
-* performs its read, and only then closes — the next queued call re-resolves
-* a fresh handle.
-*
-* The key is a digest of the resolved target, never the raw URL, so a
-* credential-bearing connection string is not retained in this map.
-*/
-var runtimeReadQueues = /* @__PURE__ */ new Map();
-function connectionQueueKey(args) {
-	const target = args.dbUrl?.trim() || process.env.SMRT_DEV_DB_URL?.trim() || "cli.config";
-	return createHash("sha256").update(target).digest("hex");
+function findUiShellDrift(packages, projectPath) {
+	return packages.flatMap((pkg) => {
+		if (!(pkg.sourceFiles.some((file) => file.path.endsWith(".svelte")) || /(?:web|ui|app|site|frontend)/i.test(packageLabel(pkg)) || pkg.dependencies.has("svelte") || pkg.dependencies.has("vite"))) return [];
+		if (pkg.dependencies.has("@happyvertical/smrt-svelte")) return [];
+		return [{
+			severity: "low",
+			area: "ui-shell",
+			code: "missing-smrt-svelte-shell",
+			title: `${packageLabel(pkg)} looks like UI work without @happyvertical/smrt-svelte`,
+			evidence: [{
+				filePath: relative(projectPath, pkg.packageJsonPath),
+				detail: "UI-facing package does not declare @happyvertical/smrt-svelte."
+			}],
+			recommendation: "Use @happyvertical/smrt-svelte and the SvelteKit shell pattern for downstream app UI unless this package is intentionally framework-agnostic.",
+			suggestedIssueTitle: `Check SMRT Svelte shell alignment for ${packageLabel(pkg)}`
+		}];
+	});
 }
-async function enqueueRuntimeRead(key, operation) {
-	const run = (runtimeReadQueues.get(key) ?? Promise.resolve()).then(operation, operation);
-	const tail = run.catch(() => void 0);
-	runtimeReadQueues.set(key, tail);
-	tail.then(() => {
-		if (runtimeReadQueues.get(key) === tail) runtimeReadQueues.delete(key);
+function findMissingManifestArtifacts(sourceFiles, packages, projectPath) {
+	return packages.flatMap((pkg) => {
+		if (!pkg.sourceFiles.some((file) => /@smrt\s*\(/.test(file.content))) return [];
+		if (sourceFiles.some((file) => file.packageDir === pkg.directory && /@happyvertical\/smrt-scanner/.test(file.content)) || pathExistsSyncHint(join(pkg.directory, ".smrt", "manifest.json")) || pathExistsSyncHint(join(pkg.directory, "dist", "manifest.json"))) return [];
+		return [{
+			severity: "low",
+			area: "manifest",
+			code: "missing-generated-manifest-artifact",
+			title: `${packageLabel(pkg)} has @smrt objects but no generated manifest artifact was found`,
+			evidence: [{
+				filePath: relative(projectPath, pkg.packageJsonPath),
+				detail: "No .smrt/manifest.json or dist/manifest.json was visible during review."
+			}],
+			recommendation: "Run the package build/test manifest generation path and verify it uses the SMRT scanner/runtime manifest pipeline.",
+			suggestedIssueTitle: `Verify SMRT manifest generation for ${packageLabel(pkg)}`
+		}];
 	});
-	return run;
-}
-/**
-* Run one read against the optional runtime connection, mapping every outcome
-* to a successful MCP envelope:
-*
-* - no connection configured → static-only envelope (`connected: false`)
-* - connect failure → static envelope with a safe diagnostic
-* - read failure → connected envelope with a safe diagnostic
-* - success → live result under `provenance: 'runtime (live DB)'`; a
-*   category-unavailable reader result keeps its `available: false` data and
-*   surfaces its message as a diagnostic
-*/
-async function withRuntimeConnection(args, read, staticHint) {
-	return enqueueRuntimeRead(connectionQueueKey(args), () => runWithRuntimeConnection(args, read, staticHint));
 }
-async function runWithRuntimeConnection(args, read, staticHint) {
-	let resolved;
+async function visit(dir, onFile) {
+	let entries;
 	try {
-		resolved = await resolveRuntimeConnection(args);
-	} catch (error) {
-		return {
-			ok: true,
-			coverage: null,
-			diagnostics: [{
-				severity: "warning",
-				code: "runtime_connection_error",
-				message: safeErrorMessage(error)
-			}],
-			data: {
-				provenance: STATIC_PROVENANCE,
-				connected: false
-			}
-		};
+		entries = await readdir(dir, { withFileTypes: true });
+	} catch {
+		return;
 	}
-	if (!resolved.db) return {
-		ok: true,
-		coverage: null,
-		diagnostics: [{
-			severity: "info",
-			code: "runtime_connection_unavailable",
-			message: `No runtime dev database configured (set SMRT_DEV_DB_URL or cli.database); returning static-only result: ${staticHint}. Static tools are unaffected.`
-		}],
-		data: {
-			provenance: STATIC_PROVENANCE,
-			connected: false
+	for (const entry of entries) {
+		const fullPath = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (SKIP_DIRS.has(entry.name)) continue;
+			await visit(fullPath, onFile);
+			continue;
 		}
-	};
-	const { db, source, displayUrl, databaseType } = resolved;
-	try {
-		const { data, diagnostics } = await read(db);
-		return {
-			ok: true,
-			coverage: null,
-			diagnostics,
-			data: {
-				provenance: RUNTIME_PROVENANCE,
-				connected: true,
-				connectionSource: source,
-				databaseType,
-				displayUrl,
-				...data
-			}
-		};
-	} catch (error) {
-		return {
-			ok: true,
-			coverage: null,
-			diagnostics: [{
-				severity: "warning",
-				code: "runtime_read_error",
-				message: safeErrorMessage(error)
-			}],
-			data: {
-				provenance: RUNTIME_PROVENANCE,
-				connected: true,
-				connectionSource: source,
-				databaseType,
-				displayUrl
-			}
-		};
-	} finally {
-		await closeRuntimeConnection(db);
+		if (entry.isFile()) await onFile(fullPath, entry.name);
 	}
 }
-/**
-* Stored error columns (`error_message`, `last_error`) are free text written
-* at failure time and routinely quote connection URLs or credentials. Every
-* string in a live result passes through {@link redactConnectionString}
-* before it reaches an MCP client; structure and non-string values are kept.
-*/
-function redactStrings(value) {
-	if (typeof value === "string") return redactConnectionString(value);
-	if (Array.isArray(value)) return value.map((item) => redactStrings(item));
-	if (value !== null && typeof value === "object") {
-		const out = {};
-		for (const [key, item] of Object.entries(value)) out[key] = redactStrings(item);
-		return out;
+function collectDependencies(packageJson) {
+	const dependencies = /* @__PURE__ */ new Set();
+	for (const sectionName of DEPENDENCY_SECTIONS) {
+		const section = packageJson[sectionName];
+		if (!isRecord$1(section)) continue;
+		for (const dependencyName of Object.keys(section)) dependencies.add(dependencyName);
 	}
-	return value;
+	return dependencies;
 }
-/** Convert a reader result into envelope data + diagnostics. */
-function toEnvelopeParts(rawResult) {
-	const result = redactStrings(rawResult);
-	if (result !== null && typeof result === "object" && "available" in result && result.available === false) {
-		const unavailable = result;
-		const { message, ...rest } = unavailable;
-		return {
-			data: rest,
-			diagnostics: [{
-				severity: unavailable.reason === "retired" ? "info" : "warning",
-				code: `category_unavailable_${String(unavailable.reason).replace(/-/g, "_")}`,
-				message: String(message)
-			}]
-		};
+function extractImports(content) {
+	const imports = /* @__PURE__ */ new Set();
+	for (const pattern of [
+		/(?:import|export)\s+(?:type\s+)?(?:[^'"]+\s+from\s+)?['"]([^'"]+)['"]/g,
+		/\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+		/\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+	]) for (const match of content.matchAll(pattern)) {
+		const imported = normalizePackageImport(match[1]);
+		if (imported) imports.add(imported);
+	}
+	return Array.from(imports);
+}
+function normalizePackageImport(value) {
+	if (!value || value.startsWith(".") || value.startsWith("/")) return void 0;
+	if (value.startsWith("@")) {
+		const [scope, name] = value.split("/");
+		return scope && name ? `${scope}/${name}` : value;
 	}
+	return value.split("/")[0];
+}
+function findOwningPackage(filePath, packages) {
+	const normalized = resolve(filePath);
+	return packages.filter((pkg) => normalized === pkg.directory || normalized.startsWith(`${pkg.directory}${sep}`)).sort((left, right) => right.directory.length - left.directory.length)[0] ?? packages[0];
+}
+function packageInventory(pkg) {
+	const declaredHappyVerticalDependencies = Array.from(pkg.dependencies).filter((dependency) => dependency.startsWith(HAPPYVERTICAL_PACKAGE_PREFIX)).sort();
+	const importedHappyVerticalPackages = Array.from(pkg.imports.keys()).sort();
+	const ownName = typeof pkg.json.name === "string" ? pkg.json.name : void 0;
 	return {
-		data: result,
-		diagnostics: []
+		name: packageLabel(pkg),
+		path: pkg.relativePath,
+		private: typeof pkg.json.private === "boolean" ? pkg.json.private : void 0,
+		scripts: Object.keys(pkg.scripts).sort(),
+		declaredHappyVerticalDependencies,
+		importedHappyVerticalPackages,
+		missingHappyVerticalDependencies: importedHappyVerticalPackages.filter((name) => name !== ownName && !pkg.dependencies.has(name)),
+		hasSvelteKit: pkg.dependencies.has("@sveltejs/kit"),
+		hasSmrtSvelte: pkg.dependencies.has("@happyvertical/smrt-svelte")
 	};
 }
-function readToParts(read) {
-	return read.then((result) => toEnvelopeParts(result));
+function summarizeFindings(findings) {
+	return findings.reduce((summary, finding) => {
+		summary[finding.severity]++;
+		return summary;
+	}, {
+		high: 0,
+		medium: 0,
+		low: 0
+	});
 }
-async function runtimeMigrationStatus(args = {}) {
-	const { limit, ...connectionArgs } = args;
-	return withRuntimeConnection(connectionArgs, (db) => readToParts(readMigrationStatus(db, { limit })), "no migration status — the manifest still reports the declared schema");
+function limitFindings(findings, maxFindings) {
+	const sorted = findings.sort((left, right) => severityRank(left.severity) - severityRank(right.severity) || left.area.localeCompare(right.area) || left.title.localeCompare(right.title));
+	return maxFindings && maxFindings > 0 ? sorted.slice(0, maxFindings) : sorted;
 }
-async function runtimeJobHealth(args = {}) {
-	const { limit, ...connectionArgs } = args;
-	return withRuntimeConnection(connectionArgs, (db) => readToParts(readJobHealth(db, { limit })), "no job health snapshot — the manifest still reports declared job queues");
+function severityRank(severity) {
+	return severity === "high" ? 0 : severity === "medium" ? 1 : 2;
 }
-async function runtimeScheduleHealth(args = {}) {
-	const { limit, ...connectionArgs } = args;
-	return withRuntimeConnection(connectionArgs, (db) => readToParts(readScheduleHealth(db, { limit })), "no schedule health snapshot — the manifest still reports declared schedules");
+function packageLabel(pkg) {
+	return typeof pkg.json.name === "string" ? pkg.json.name : pkg.relativePath;
 }
-async function runtimeDispatchHealth(args = {}) {
-	const { limit, ...connectionArgs } = args;
-	return withRuntimeConnection(connectionArgs, (db) => readToParts(readDispatchHealth(db, { limit })), "no dispatch health snapshot — the manifest still reports declared dispatch topology");
+function lineNumber(content, needle) {
+	const index = content.indexOf(needle);
+	if (index < 0) return void 0;
+	return content.slice(0, index).split("\n").length;
 }
-async function runtimeRecentChanges(args = {}) {
-	const { since, tables, tenantId, limit, ...connectionArgs } = args;
-	return withRuntimeConnection(connectionArgs, (db) => readToParts(readRecentChanges(db, {
-		since,
-		tables,
-		tenantId,
-		limit
-	})), "no recent changes — static knowledge artifacts are unchanged");
+function isRecord$1(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
 }
-async function runtimeRegistryDrift(args = {}) {
-	return withRuntimeConnection(args, (db) => readToParts(readRegistryDrift(db)), "no registry drift report — _smrt_registry is retired; declared objects come from the manifest");
+async function pathExists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function pathExistsSyncHint(path) {
+	return existsSync(path);
 }
 //#endregion
 //#region src/index.ts
@@ -1451,8 +1888,6 @@ async function runtimeRegistryDrift(args = {}) {
 * Provides code generation, project introspection, knowledge context,
 * review/architecture prompt bundles, and portable agent skills.
 */
-var SERVER_NAME = "smrt-dev-mcp";
-var SERVER_VERSION = readPackageVersion();
 var DEBUG = process.env.DEBUG === "true";
 var REVIEW_SKILL_URI = `smrt-dev-mcp://agent-skills/${REVIEW_SKILL_NAME}`;
 var DOMAIN_CODE_REVIEW_PROMPT = "domain-code-review";
@@ -1815,6 +2250,15 @@ function createServer() {
 				case "registry-drift":
 					result = JSON.stringify(await runtimeRegistryDrift(args), null, 2);
 					break;
+				case "runtime-registry":
+					result = JSON.stringify(await runtimeRegistry(args), null, 2);
+					break;
+				case "runtime-object":
+					result = JSON.stringify(await runtimeObject(args), null, 2);
+					break;
+				case "runtime-schema-diff":
+					result = JSON.stringify(await runtimeSchemaDiff(args), null, 2);
+					break;
 				default: throw new Error(`Unknown tool: ${name}`);
 			}
 			return {
@@ -1870,15 +2314,6 @@ function isEntrypoint() {
 		return import.meta.url === pathToFileURL(entry).href;
 	}
 }
-function readPackageVersion() {
-	try {
-		const packageJsonPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-		return typeof packageJson.version === "string" ? packageJson.version : "0.0.0";
-	} catch {
-		return "0.0.0";
-	}
-}
 function renderAgentSkillMarkdown(name) {
 	const skill = getAgentSkill({
 		name,
@@ -1995,11 +2430,53 @@ function sanitizePath(path) {
 	if (path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path)) return "<absolute-path>";
 	return path;
 }
-if (isEntrypoint()) main().catch((error) => {
-	console.error(`[${SERVER_NAME}] Fatal error:`, error);
-	process.exit(1);
-});
+/**
+* `smrt-dev-mcp --http [--port N] [--project DIR]` starts the Level 2 runtime
+* dev-plane host (#1831) instead of the stdio server. Loopback-only, bearer
+* protected, positive read-only catalog; see `http.ts`.
+*/
+function parseHttpCliArgs(argv) {
+	const result = { http: false };
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (arg === "--http") result.http = true;
+		else if (arg === "--port") {
+			const value = Number.parseInt(argv[index + 1] ?? "", 10);
+			if (!Number.isInteger(value) || value < 0 || value > 65535) throw new Error("--port requires an integer between 0 and 65535");
+			result.port = value;
+			index += 1;
+		} else if (arg === "--project") {
+			const value = argv[index + 1];
+			if (!value) throw new Error("--project requires a directory");
+			result.projectRoot = value;
+			index += 1;
+		}
+	}
+	return result;
+}
+async function mainHttp(cli) {
+	const host = await startRuntimeHttpHost({
+		port: cli.port,
+		projectRoot: cli.projectRoot
+	});
+	const minted = !process.env.SMRT_DEV_MCP_TOKEN?.trim();
+	console.error(`[${SERVER_NAME}] runtime dev-plane listening at ${host.url} (${host.boot.objectCount} booted objects, ${host.boot.manifests.length} manifests)`);
+	if (minted) console.error(`[${SERVER_NAME}] bearer token: ${host.token}`);
+	const shutdown = async () => {
+		await host.close();
+		process.exit(0);
+	};
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
+}
+if (isEntrypoint()) {
+	const cli = parseHttpCliArgs(process.argv.slice(2));
+	(cli.http ? mainHttp(cli) : main()).catch((error) => {
+		console.error(`[${SERVER_NAME}] Fatal error:`, error);
+		process.exit(1);
+	});
+}
 //#endregion
-export { SERVER_VERSION, TOOLS, createServer };
+export { SERVER_VERSION, TOOLS, createServer, parseHttpCliArgs };
 
 //# sourceMappingURL=index.js.map