@happyvertical/smrt-dev-mcp 0.47.2 → 0.49.0

package/dist/index.js

@@ -1,18 +1,13 @@
 #!/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-CY6sQzpj.js";
+import { i as SERVER_VERSION, n as startRuntimeHttpHost, r as SERVER_NAME } from "./http-TeoaK9Xr.js";
+import { n as TOOLS, t as REVIEW_SKILL_NAME } from "./tool-catalog-Zl-bcimC.js";
+import { c as runtimeMigrationStatus, d as runtimeScheduleHealth, f as redactConnectionString, l as runtimeRecentChanges, n as runtimeRegistry, o as runtimeDispatchHealth, r as runtimeSchemaDiff, s as runtimeJobHealth, t as runtimeObject, u as runtimeRegistryDrift } from "./observation-VJgHaPps.js";
+import { a as buildReviewContext, c as compactContextResult, i as buildPackageSpecialistContext, n as buildContext, o as checkKnowledgeFreshness, r as buildKnowledgeIndex, s as checkKnowledgeFreshnessFromIndex, t as buildArchitectureContext } from "./knowledge-BOsSAdPo.js";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { ProtocolError, ProtocolErrorCode, Server, createMcpHandler } from "@modelcontextprotocol/server";
+import { ProtocolError, ProtocolErrorCode, Server } from "@modelcontextprotocol/server";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
-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 { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { ManifestAdapter, OxcScanner } from "@happyvertical/smrt-scanner";
 import { access, readFile, readdir } from "node:fs/promises";
 import { ManifestGenerator } from "@happyvertical/smrt-core/scanner";
@@ -51,828 +46,6 @@ function resolvePackageRoot() {
 	return packageRoot;
 }
 //#endregion
-//#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";
-	}
-}
-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 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;
-}
-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;
-}
-/**
-* 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."
-	});
-	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 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/runtime/connection.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.
-*/
-var RUNTIME_DATABASE_TYPES = [
-	"sqlite",
-	"postgres",
-	"duckdb"
-];
-function isRuntimeDatabaseType(value) {
-	return RUNTIME_DATABASE_TYPES.includes(value);
-}
-/**
-* 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, "");
-}
-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");
-	}
-	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);
-}
-/**
-* 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"));
-}
-/**
-* 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`);
-}
-/** 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";
-}
-/**
-* 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
-		};
-	}
-	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
-		};
-	}
-	return {
-		db: null,
-		source: "none",
-		displayUrl: "",
-		databaseType: null
-	};
-}
-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 {};
-	}
-}
-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 {}
-}
-//#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: {
@@ -1097,7 +270,7 @@ var DEFAULT_MCP_OPERATIONS = [
 	"delete"
 ];
 async function introspectProject(args) {
-	const { directory = process.cwd(), includeFields = true, includeRelationships = true, includeMethods = true, detail = "summary", maxChars = DEFAULT_MAX_CHARS } = args;
+	const { directory = process.cwd(), includeFields = true, includeRelationships = true, includeMethods = true, detail = "summary", maxChars = DEFAULT_MAX_CHARS, cursor, limit } = args;
 	const projectPath = resolve(directory);
 	if (!await pathExists$1(projectPath)) return JSON.stringify({
 		projectPath,
@@ -1128,7 +301,11 @@ async function introspectProject(args) {
 		tenantScope: tenantScopes.get(object.className)
 	}));
 	objects.sort((left, right) => left.className.localeCompare(right.className));
-	const { kept, omitted } = applyObjectBudget(objects, maxChars);
+	const afterCursor = typeof cursor === "string" && cursor.length > 0 ? objects.filter((object) => object.className.localeCompare(cursor) > 0) : objects;
+	const pageLimit = typeof limit === "number" && Number.isFinite(limit) && limit >= 1 ? Math.floor(limit) : void 0;
+	const { kept, omitted: budgetOmitted } = applyObjectBudget(pageLimit !== void 0 ? afterCursor.slice(0, pageLimit) : afterCursor, maxChars);
+	const omitted = afterCursor.length - kept.length;
+	const nextCursor = omitted > 0 && kept.length > 0 ? kept[kept.length - 1].className : void 0;
 	const output = {
 		projectPath,
 		manifestSource: manifestResult.source,
@@ -1139,11 +316,14 @@ async function introspectProject(args) {
 		objectCount: objects.length,
 		scannedFileCount: manifestResult.scannedFileCount,
 		parseTimeMs: manifestResult.parseTimeMs,
+		...cursor ? { cursor } : {},
+		...nextCursor ? { nextCursor } : {},
 		...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."
+			...pageLimit !== void 0 ? { limit: pageLimit } : {},
+			guidance: budgetOmitted > 0 ? "The object list hit its character budget; metadata and diagnostics are still complete. Pass `cursor: nextCursor` to read the next page, narrow the scan with `directory`, keep `detail: \"summary\"`, or raise `maxChars` deliberately. Objects are sorted alphabetically." : "More objects follow this page. Pass `cursor: nextCursor` to continue."
 		} } : {},
 		objects: kept,
 		diagnostics: manifestResult.diagnostics
@@ -2206,26 +1386,27 @@ function createServer() {
 				case "check-knowledge-freshness":
 					result = JSON.stringify(await checkKnowledgeFreshness(args), null, 2);
 					break;
-				case "check-domain-knowledge":
-					result = JSON.stringify(await checkKnowledgeFreshness(args), null, 2);
-					break;
-				case "build-review-context":
-				case "build-domain-review-context":
-					result = JSON.stringify(compactContextResult(await buildReviewContext(args), detailArg(args)), null, 2);
+				case "build-context":
+					result = JSON.stringify(compactContextResult(await buildContext(args), detailArg(args)), null, 2);
 					break;
 				case "smrt-review":
-					result = JSON.stringify(compactContextResult(await smrtReview(args), detailArg(args)), null, 2);
+				case "smrt-architecture": {
+					const task = name === "smrt-review" ? "review" : "architecture";
+					const context = compactContextResult(await buildContext({
+						...args,
+						task
+					}), detailArg(args));
+					context.diagnostics = [...Array.isArray(context.diagnostics) ? context.diagnostics : [], {
+						severity: "info",
+						code: "deprecated_tool_name",
+						message: `${name} is a compatibility name; call build-context with task: '${task}'. It will be removed in the next minor release.`
+					}];
+					result = JSON.stringify(context, null, 2);
 					break;
+				}
 				case "build-package-specialist-context":
 					result = JSON.stringify(sanitizePackageSpecialist(await buildPackageSpecialistContext(args)), null, 2);
 					break;
-				case "build-architecture-context":
-				case "build-domain-architecture-context":
-					result = JSON.stringify(compactContextResult(await buildArchitectureContext(args), detailArg(args)), null, 2);
-					break;
-				case "smrt-architecture":
-					result = JSON.stringify(compactContextResult(await smrtArchitecture(args), detailArg(args)), null, 2);
-					break;
 				case "list-agent-skills":
 					result = JSON.stringify({ skills: listAgentSkills() }, null, 2);
 					break;