onto-mcp 0.3.0 → 0.3.2

package/dist/core-runtime/cli/review-invoke.js

@@ -11,14 +11,17 @@ import { executeReviewPromptExecution, } from "./run-review-prompt-execution.js"
 import { startReviewSession } from "./start-review-session.js";
 import { spawnWatcherPane } from "./spawn-watcher.js";
 import { generateReviewSessionId } from "../review/materializers.js";
-import { fileExists, hasOptionFlag, normalizeDomainValue, readMultiOptionValuesFromArgv, readYamlDocument, readSingleOptionValueFromArgv, } from "../review/review-artifact-utils.js";
+import { fileExists, hasOptionFlag, isDeprecatedDomainAlias, normalizeDomainValue, readMultiOptionValuesFromArgv, readYamlDocument, readSingleOptionValueFromArgv, } from "../review/review-artifact-utils.js";
 import { printOntoReleaseChannelNotice } from "../release-channel/release-channel.js";
-import { resolveOntoHome } from "../discovery/onto-home.js";
+import { isOntoRoot, resolveOntoHome } from "../discovery/onto-home.js";
+import { resolveInstallationPath } from "../discovery/installation-paths.js";
 import { resolveSettingsChain } from "../discovery/settings-chain.js";
 import { loadCoreLensRegistry } from "../discovery/lens-registry.js";
+import { isPathInsideRoot, isPathInsideRootRealpathAwareSync, } from "../path-boundary.js";
 import { normalizeLlmModelSwitcher } from "../llm/model-switcher.js";
 import { resolveReviewExecutionProfile, } from "../review/review-execution-profile.js";
 import { buildReviewExecutionRoute } from "../review/review-execution-route.js";
+import { prepareReviewInvocationArgv, runReviewInvocationArgv, } from "../review/review-invocation-runner.js";
 import { readValidatedReviewRecord } from "../review/review-record-validation.js";
 import { readReviewResultClassification } from "../review/review-result-classification.js";
 import { createStructuredFailureRecord, ReviewStructuredFailureError, writeAndThrowStructuredFailureRecord, } from "../review/failure-records.js";
@@ -124,7 +127,7 @@ function resolveDirectExecutorPath(realization, ontoHome) {
     }
     return null;
 }
-function buildExecutorConfigFromRealization(realization, ontoHome) {
+export function buildExecutorConfigFromRealization(realization, ontoHome) {
     if (typeof ontoHome === "string" && ontoHome.length > 0) {
         const direct = resolveDirectExecutorPath(realization, ontoHome);
         if (direct) {
@@ -139,7 +142,7 @@ function buildExecutorConfigFromRealization(realization, ontoHome) {
     }
     throw new Error("ontoHome is required to resolve review executor script paths.");
 }
-function inferExecutorRealization(config) {
+export function inferExecutorRealization(config) {
     const joinedArgs = config.args.join(" ");
     for (const [realization, filename] of Object.entries(EXECUTOR_SCRIPT_FILENAMES)) {
         if (joinedArgs.includes(filename)) {
@@ -179,10 +182,6 @@ function applyExecutorOverrideToProfile(profile, argv) {
     }
     return profile;
 }
-function isInsidePath(root, candidate) {
-    const relative = path.relative(path.resolve(root), path.resolve(candidate));
-    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
-}
 function displayPathFromProject(projectRoot, candidate) {
     if (!path.isAbsolute(candidate))
         return candidate;
@@ -217,7 +216,7 @@ function renderReviewStartPreview(args) {
     const { projectRoot, sessionRoot, setup, reviewExecutionProfile } = args;
     const inputs = setup.resolvedInvokeInputs;
     const targetPath = path.resolve(inputs.targetPath);
-    const boundaryLabel = isInsidePath(projectRoot, targetPath)
+    const boundaryLabel = isPathInsideRoot(projectRoot, targetPath)
         ? "project"
         : "external";
     const projectSettingsPath = path.join(projectRoot, ".onto", "settings.json");
@@ -246,6 +245,7 @@ function renderReviewStartPreview(args) {
         `  selected: ${selectedDomain}`,
         `  selection_mode: ${inputs.domainSelectionMode}`,
         `  selection_required: ${String(inputs.domainSelectionRequired)}`,
+        `  selection_reason: ${inputs.domainSelectionReason}`,
         "review_lenses:",
         `  review_mode: ${inputs.reviewMode}`,
         `  lens_count: ${configuredLensIds.length}`,
@@ -337,7 +337,7 @@ function renderScreenBoundedLines(text, maxLines = 10) {
     }
     return bounded;
 }
-async function readReviewResultExplanationSummary(finalOutputPath) {
+export async function readReviewResultExplanationSummary(finalOutputPath) {
     if (!(await fileExists(finalOutputPath))) {
         const unavailable = "- final output unavailable";
         return {
@@ -357,7 +357,7 @@ async function readReviewResultExplanationSummary(finalOutputPath) {
         screen_lines: renderScreenBoundedLines(finalReviewResult),
     };
 }
-async function readReviewResultClosureSummary(sessionRoot) {
+export async function readReviewResultClosureSummary(sessionRoot) {
     const problemFramingPath = path.join(sessionRoot, "problem-framing.yaml");
     const resultClassification = await readReviewResultClassification(sessionRoot);
     const problemFraming = (await fileExists(problemFramingPath))
@@ -407,6 +407,7 @@ function renderReviewResultOverview(args) {
         `  target: ${args.target}`,
         `  target_scope_kind: ${args.targetScopeKind}`,
         `  domain: ${args.domain.length > 0 ? args.domain : "none"}`,
+        `  domain_selection_reason: ${args.domainSelectionReason}`,
         "coverage:",
         `  lenses: ${args.participatingLensIds.length}/${args.plannedLensIds.length} participating`,
         `  degraded_lenses: ${degraded}`,
@@ -613,7 +614,7 @@ function buildNoHostDetectedError() {
         "  4. 테스트 실행은 --executor-realization mock 사용",
     ].join("\n"));
 }
-function resolveExecutorConfig(argv, optionPrefix, ontoConfig, ontoHome, reviewExecutionProfile, actor = "lens") {
+export function resolveExecutorConfig(argv, optionPrefix, ontoConfig, ontoHome, reviewExecutionProfile, actor = "lens") {
     const optionPrefixLabel = optionPrefix.length > 0 ? optionPrefix : "";
     const actorLlmRef = reviewExecutionProfile?.[actor].llm;
     const explicitBin = readSingleOptionValueFromArgv(argv, `${optionPrefixLabel}executor-bin`);
@@ -684,7 +685,7 @@ function assertValidLocalBaseUrl(baseUrl) {
         throw new Error(`Invalid local provider base_url: ${baseUrl}`);
     }
 }
-async function ensureProviderRouteReadyForDispatch(args) {
+export async function ensureProviderRouteReadyForDispatch(args) {
     const profile = args.reviewExecutionProfile;
     if (profile.worker_executor === "mock") {
         return;
@@ -855,26 +856,6 @@ function parseHostFacingPositionals(positionals) {
         intentText: [second, ...rest].filter((value) => typeof value === "string").join(" ").trim(),
     };
 }
-function isPathInsideRoot(candidatePath, rootPath) {
-    let resolvedCandidate;
-    let resolvedRoot;
-    try {
-        resolvedCandidate = fsSync.realpathSync(candidatePath);
-        resolvedRoot = fsSync.realpathSync(rootPath);
-    }
-    catch {
-        resolvedCandidate = path.resolve(candidatePath);
-        resolvedRoot = path.resolve(rootPath);
-    }
-    const relative = path.relative(resolvedRoot, resolvedCandidate);
-    if (relative === "") {
-        return true;
-    }
-    if (relative.startsWith("..")) {
-        return false;
-    }
-    return !path.isAbsolute(relative);
-}
 function normalizeFilesystemAllowedRoot(root, defaultProjectRoot) {
     if (path.isAbsolute(root)) {
         return path.resolve(root);
@@ -894,7 +875,7 @@ function normalizeFilesystemAllowedRoots(filesystemAllowedRoots, defaultProjectR
     return deduped;
 }
 function isInsideAnyDeclaredFilesystemRoot(targetPath, allowedRoots) {
-    return allowedRoots.some((allowedRoot) => isPathInsideRoot(targetPath, allowedRoot));
+    return allowedRoots.some((allowedRoot) => isPathInsideRootRealpathAwareSync(allowedRoot, targetPath));
 }
 function deriveFilesystemBoundaryFromTarget(targetPath, targetScopeKind) {
     return targetScopeKind === "file"
@@ -960,10 +941,11 @@ function normalizeDomainToken(domainValue) {
     if (trimmed.length === 0) {
         return null;
     }
-    if (["-", "@-", "none"].includes(trimmed)) {
+    const normalized = normalizeDomainValue(trimmed);
+    if (normalized === "none") {
         return "@-";
     }
-    return trimmed.startsWith("@") ? trimmed : `@${trimmed}`;
+    return `@${normalized}`;
 }
 function collectConfiguredDomainTokens(ontoConfig) {
     const collected = [];
@@ -996,6 +978,313 @@ function collectConfiguredDomainTokens(ontoConfig) {
     pushTokenList(ontoConfig.domains);
     return collected;
 }
+const DOMAIN_INFERENCE_MAX_FILE_BYTES = 64 * 1024;
+const DOMAIN_INFERENCE_MAX_DIRECTORY_ENTRIES = 200;
+const DOMAIN_INFERENCE_MAX_DIRECTORY_DEPTH = 3;
+const DOMAIN_INFERENCE_MIN_SCORE = 18;
+const DOMAIN_INFERENCE_EXCLUDED_NAMES = new Set([
+    ".git",
+    "node_modules",
+    ".onto/review",
+    "dist",
+    "build",
+    ".next",
+    "coverage",
+]);
+const DOMAIN_INFERENCE_CODE_EXTENSIONS = new Set([
+    ".c",
+    ".cc",
+    ".cpp",
+    ".cs",
+    ".go",
+    ".java",
+    ".js",
+    ".jsx",
+    ".kt",
+    ".mjs",
+    ".py",
+    ".rs",
+    ".swift",
+    ".ts",
+    ".tsx",
+]);
+const DOMAIN_INFERENCE_STOPWORDS = new Set([
+    "a",
+    "an",
+    "and",
+    "are",
+    "as",
+    "be",
+    "by",
+    "can",
+    "code",
+    "content",
+    "data",
+    "doc",
+    "document",
+    "domain",
+    "file",
+    "for",
+    "from",
+    "has",
+    "in",
+    "is",
+    "it",
+    "of",
+    "on",
+    "or",
+    "review",
+    "rule",
+    "should",
+    "system",
+    "target",
+    "that",
+    "the",
+    "this",
+    "to",
+    "with",
+]);
+function addDomainRootCandidates(args) {
+    if (!fsSync.existsSync(args.root))
+        return;
+    let entries;
+    try {
+        entries = fsSync.readdirSync(args.root, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith("."))
+            continue;
+        if (isDeprecatedDomainAlias(entry.name))
+            continue;
+        if (args.seenIds.has(entry.name))
+            continue;
+        args.seenIds.add(entry.name);
+        args.candidates.push({
+            id: entry.name,
+            dir: path.join(args.root, entry.name),
+            source: args.source,
+        });
+    }
+}
+function collectAvailableDomainCandidates(projectRoot, ontoHome) {
+    const candidates = [];
+    const seenIds = new Set();
+    const seenRoots = new Set();
+    const addRoot = (root, source) => {
+        const resolvedRoot = path.resolve(root);
+        if (seenRoots.has(resolvedRoot))
+            return;
+        seenRoots.add(resolvedRoot);
+        addDomainRootCandidates({ candidates, seenIds, root: resolvedRoot, source });
+    };
+    addRoot(path.join(projectRoot, ".onto", "domains"), "project");
+    addRoot(path.join(os.homedir(), ".onto", "domains"), "user");
+    if (typeof ontoHome === "string" && ontoHome.length > 0) {
+        try {
+            addRoot(resolveInstallationPath("domains", ontoHome), "installation");
+        }
+        catch {
+            // No installation domain seat available.
+        }
+    }
+    if (isOntoRoot(projectRoot)) {
+        try {
+            addRoot(resolveInstallationPath("domains", projectRoot), "dev_install");
+        }
+        catch {
+            // Not a canonical install domain seat.
+        }
+    }
+    return candidates;
+}
+function tokenizeForDomainInference(text) {
+    return text
+        .toLowerCase()
+        .replace(/[-_/.:]+/g, " ")
+        .split(/[^\p{L}\p{N}]+/u)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 3 &&
+        !DOMAIN_INFERENCE_STOPWORDS.has(token) &&
+        !/^\d+$/.test(token));
+}
+async function readFilePrefix(filePath, maxBytes) {
+    let handle;
+    try {
+        const stats = await fs.stat(filePath);
+        const byteLength = Math.min(stats.size, maxBytes);
+        if (byteLength <= 0)
+            return "";
+        handle = await fs.open(filePath, "r");
+        const buffer = Buffer.alloc(byteLength);
+        const { bytesRead } = await handle.read(buffer, 0, byteLength, 0);
+        return buffer.subarray(0, bytesRead).toString("utf8");
+    }
+    catch {
+        return "";
+    }
+    finally {
+        await handle?.close();
+    }
+}
+async function collectDirectorySignalPaths(root, maxEntries = DOMAIN_INFERENCE_MAX_DIRECTORY_ENTRIES, maxDepth = DOMAIN_INFERENCE_MAX_DIRECTORY_DEPTH) {
+    const collected = [];
+    async function walk(current, depth) {
+        if (collected.length >= maxEntries || depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            if (collected.length >= maxEntries)
+                return;
+            const relative = path.relative(root, path.join(current, entry.name));
+            const normalizedRelative = relative.split(path.sep).join(path.posix.sep);
+            if (DOMAIN_INFERENCE_EXCLUDED_NAMES.has(entry.name) ||
+                DOMAIN_INFERENCE_EXCLUDED_NAMES.has(normalizedRelative)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                await walk(path.join(current, entry.name), depth + 1);
+                continue;
+            }
+            if (entry.isFile()) {
+                collected.push(normalizedRelative);
+            }
+        }
+    }
+    await walk(root, 0);
+    return collected;
+}
+async function buildTargetDomainSignal(args) {
+    const pathParts = [
+        args.requestedTarget,
+        path.relative(args.projectRoot, args.targetPath),
+        ...args.resolvedTargetRefs.map((ref) => path.relative(args.projectRoot, ref)),
+    ].map((part) => part.split(path.sep).join(path.posix.sep));
+    const contentParts = [args.requestText, ...pathParts];
+    let hasCodeSignal = false;
+    let hasOntologyPathSignal = pathParts.some((part) => part === ".onto" ||
+        part.startsWith(".onto/") ||
+        part.includes("/ontology/") ||
+        part.includes("ontology"));
+    for (const ref of args.resolvedTargetRefs) {
+        try {
+            const stats = await fs.stat(ref);
+            if (stats.isDirectory()) {
+                const listedPaths = await collectDirectorySignalPaths(ref);
+                contentParts.push(...listedPaths);
+                hasCodeSignal ||= listedPaths.some((listedPath) => DOMAIN_INFERENCE_CODE_EXTENSIONS.has(path.extname(listedPath)));
+                hasOntologyPathSignal ||= listedPaths.some((listedPath) => listedPath.startsWith(".onto/") ||
+                    listedPath.includes("/ontology/") ||
+                    listedPath.includes("ontology"));
+                continue;
+            }
+            hasCodeSignal ||= DOMAIN_INFERENCE_CODE_EXTENSIONS.has(path.extname(ref));
+            contentParts.push(await readFilePrefix(ref, DOMAIN_INFERENCE_MAX_FILE_BYTES));
+        }
+        catch {
+            // Target binding already validated refs; inference remains best-effort.
+        }
+    }
+    return {
+        text: contentParts.join("\n"),
+        pathText: pathParts.join("\n"),
+        hasCodeSignal,
+        hasOntologyPathSignal,
+    };
+}
+async function readDomainCandidateText(candidate) {
+    const preferredFiles = [
+        "domain_scope.md",
+        "concepts.md",
+        "competency_qs.md",
+        "structure_spec.md",
+        "logic_rules.md",
+    ];
+    const parts = [candidate.id, candidate.id.replace(/-/g, " ")];
+    for (const filename of preferredFiles) {
+        const filePath = path.join(candidate.dir, filename);
+        if (!fsSync.existsSync(filePath))
+            continue;
+        parts.push(await readFilePrefix(filePath, 24 * 1024));
+    }
+    return parts.join("\n");
+}
+function formatInferenceReason(args) {
+    const reason = args.signalReasons.length > 0
+        ? args.signalReasons.join("; ")
+        : "it had the strongest lexical overlap with the target and intent";
+    return `No explicit domain token or configured domain was provided. Selected ${args.domainToken} because ${reason}.`;
+}
+async function inferDomainFromReviewTarget(args) {
+    const candidates = collectAvailableDomainCandidates(args.projectRoot, args.ontoHome);
+    if (candidates.length === 0)
+        return null;
+    const signal = await buildTargetDomainSignal(args);
+    const targetTokens = new Set(tokenizeForDomainInference(signal.text));
+    const pathTokens = new Set(tokenizeForDomainInference(signal.pathText));
+    const normalizedTargetText = signal.text.toLowerCase();
+    const scored = await Promise.all(candidates.map(async (candidate, index) => {
+        let score = 0;
+        const signalReasons = [];
+        const domainToken = `@${candidate.id}`;
+        const domainIdTokens = tokenizeForDomainInference(candidate.id);
+        if (normalizedTargetText.includes(candidate.id.toLowerCase())) {
+            score += 80;
+            signalReasons.push(`the target mentions "${candidate.id}"`);
+        }
+        const matchedIdTokens = domainIdTokens.filter((token) => targetTokens.has(token) || pathTokens.has(token));
+        if (matchedIdTokens.length > 0) {
+            score += matchedIdTokens.length * 30;
+            signalReasons.push(`target path or intent matches domain token(s): ${matchedIdTokens.join(", ")}`);
+        }
+        if (candidate.id === "ontology" && signal.hasOntologyPathSignal) {
+            score += 55;
+            signalReasons.push("the target is inside or explicitly references ontology-owned material");
+        }
+        if (candidate.id === "software-engineering" && signal.hasCodeSignal) {
+            score += 45;
+            signalReasons.push("the target contains implementation/code material");
+        }
+        const domainText = await readDomainCandidateText(candidate);
+        const domainTokens = new Set(tokenizeForDomainInference(domainText));
+        const overlap = [...targetTokens].filter((token) => domainTokens.has(token));
+        if (overlap.length > 0) {
+            const weightedOverlap = Math.min(overlap.length * 2, 40);
+            score += weightedOverlap;
+            signalReasons.push(`target text overlaps domain document terms: ${overlap.slice(0, 5).join(", ")}`);
+        }
+        return {
+            candidate,
+            domainToken,
+            score,
+            index,
+            signalReasons,
+        };
+    }));
+    scored.sort((left, right) => right.score - left.score ||
+        left.index - right.index ||
+        left.candidate.id.localeCompare(right.candidate.id));
+    const best = scored[0];
+    if (!best || best.score < DOMAIN_INFERENCE_MIN_SCORE)
+        return null;
+    return {
+        domainToken: best.domainToken,
+        reason: formatInferenceReason({
+            domainToken: best.domainToken,
+            signalReasons: best.signalReasons,
+        }),
+    };
+}
 async function promptForDomainSelection(configuredDomainTokens) {
     const optionTokens = configuredDomainTokens.includes("@-")
         ? [...configuredDomainTokens]
@@ -1035,31 +1324,54 @@ async function promptForDomainSelection(configuredDomainTokens) {
         readline.close();
     }
 }
-async function resolveDomainSelection(requestedDomainToken, ontoConfig) {
+async function resolveDomainSelection(requestedDomainToken, ontoConfig, inferenceContext) {
     if (requestedDomainToken.length > 0) {
+        const domainFinalValue = normalizeDomainValue(requestedDomainToken);
+        const reason = domainFinalValue === "none"
+            ? "Explicit no-domain token was provided; runtime will run without domain documents."
+            : `Explicit domain token ${requestedDomainToken} was provided; runtime used it without target inference.`;
         return {
             domainRecommendation: requestedDomainToken,
-            domainFinalValue: normalizeDomainValue(requestedDomainToken),
+            domainFinalValue,
             domainSelectionMode: "explicit_token",
             domainSelectionRequired: false,
+            domainSelectionReason: reason,
+            bindingNotes: [reason],
         };
     }
     const configuredDomainTokens = collectConfiguredDomainTokens(ontoConfig);
     if (configuredDomainTokens.length === 0) {
+        const inferred = await inferDomainFromReviewTarget(inferenceContext);
+        if (inferred) {
+            return {
+                domainRecommendation: inferred.domainToken,
+                domainFinalValue: normalizeDomainValue(inferred.domainToken),
+                domainSelectionMode: "target_inferred",
+                domainSelectionRequired: false,
+                domainSelectionReason: inferred.reason,
+                bindingNotes: [inferred.reason],
+            };
+        }
+        const reason = "No explicit domain token, configured domain, or confident target-domain match was available; runtime will run without domain documents.";
         return {
             domainRecommendation: "@-",
             domainFinalValue: "none",
             domainSelectionMode: "no_domain_default",
             domainSelectionRequired: false,
+            domainSelectionReason: reason,
+            bindingNotes: [reason],
         };
     }
     if (configuredDomainTokens.length === 1) {
         const selectedToken = configuredDomainTokens[0];
+        const reason = `Single configured domain ${selectedToken} is available; runtime used the configured default.`;
         return {
             domainRecommendation: selectedToken,
             domainFinalValue: normalizeDomainValue(selectedToken),
             domainSelectionMode: "project_default",
             domainSelectionRequired: false,
+            domainSelectionReason: reason,
+            bindingNotes: [reason],
         };
     }
     const domainRecommendation = configuredDomainTokens[0];
@@ -1071,11 +1383,14 @@ async function resolveDomainSelection(requestedDomainToken, ontoConfig) {
         ].join("\n"));
     }
     const selectedToken = await promptForDomainSelection(configuredDomainTokens);
+    const reason = `Interactive domain selection chose ${selectedToken} from configured domains: ${configuredDomainTokens.join(", ")}.`;
     return {
         domainRecommendation,
         domainFinalValue: normalizeDomainValue(selectedToken),
         domainSelectionMode: "interactive_selection",
         domainSelectionRequired: true,
+        domainSelectionReason: reason,
+        bindingNotes: [reason],
     };
 }
 function resolveReviewMode(argv, ontoConfig) {
@@ -1268,7 +1583,7 @@ async function resolveBundleTargetInput(args) {
         filesystemAllowedRoots,
     };
 }
-async function resolveReviewInvokeInputs(argv, ontoConfig, projectRoot, sessionId) {
+async function resolveReviewInvokeInputs(argv, ontoConfig, projectRoot, sessionId, ontoHome) {
     const parsedPositionals = parseHostFacingPositionals(splitArgvIntoOptionsAndPositionals(argv, [...KNOWN_INVOKE_ONLY_OPTION_NAMES, ...KNOWN_PASSTHROUGH_OPTION_NAMES], [...KNOWN_INVOKE_ONLY_FLAG_NAMES, ...KNOWN_PASSTHROUGH_FLAG_NAMES]).positionals);
     const explicitRequestedTarget = readSingleOptionValueFromArgv(argv, "requested-target");
     const explicitTargetScopeKind = requireOptionalTargetScopeKind(readSingleOptionValueFromArgv(argv, "target-scope-kind"));
@@ -1347,7 +1662,6 @@ async function resolveReviewInvokeInputs(argv, ontoConfig, projectRoot, sessionI
     const requestedDomainToken = readSingleOptionValueFromArgv(argv, "requested-domain-token") ??
         (canonicalDomainToken.length > 0 ? canonicalDomainToken : undefined) ??
         "";
-    const resolvedDomainSelection = await resolveDomainSelection(requestedDomainToken, ontoConfig);
     let reviewMode = resolveReviewMode(argv, ontoConfig);
     const explicitLensIds = readMultiOptionValuesFromArgv(argv, "lens-id");
     // Phase 3: standalone LLM-based complexity assessment (Step 1.5)
@@ -1497,6 +1811,15 @@ async function resolveReviewInvokeInputs(argv, ontoConfig, projectRoot, sessionI
     if (resolvedLensIds.length === 0) {
         throw new Error("No lens IDs resolved. Specify at least one --lens-id or use --review-mode full|core-axis.");
     }
+    const resolvedDomainSelection = await resolveDomainSelection(requestedDomainToken, ontoConfig, {
+        projectRoot,
+        ...(ontoHome ? { ontoHome } : {}),
+        requestedTarget: requestedTarget ?? explicitPrimaryRef ?? absoluteTargetPath,
+        requestText,
+        targetPath: absoluteTargetPath,
+        targetScopeKind,
+        resolvedTargetRefs,
+    });
     return {
         requestedTarget: requestedTarget ?? explicitPrimaryRef ?? absoluteTargetPath,
         targetPath: absoluteTargetPath,
@@ -1509,6 +1832,8 @@ async function resolveReviewInvokeInputs(argv, ontoConfig, projectRoot, sessionI
         domainFinalValue: resolvedDomainSelection.domainFinalValue,
         domainSelectionMode: resolvedDomainSelection.domainSelectionMode,
         domainSelectionRequired: resolvedDomainSelection.domainSelectionRequired,
+        domainSelectionReason: resolvedDomainSelection.domainSelectionReason,
+        bindingNotes: resolvedDomainSelection.bindingNotes,
         ...(bundleKind ? { bundleKind } : {}),
         reviewMode,
         reviewModeRecommendation: reviewMode,
@@ -1537,6 +1862,15 @@ function appendReviewInvokeDerivedArgs(argv, resolvedInputs) {
             appended.push(`--${optionName}`, value);
         }
     };
+    const appendMissingMulti = (optionName, values) => {
+        const existingValues = new Set(readMultiOptionValuesFromArgv(appended, optionName));
+        for (const value of values) {
+            if (existingValues.has(value))
+                continue;
+            appended.push(`--${optionName}`, value);
+            existingValues.add(value);
+        }
+    };
     appendSingleIfAbsent("requested-target", resolvedInputs.requestedTarget);
     appendSingleIfAbsent("target-scope-kind", resolvedInputs.targetScopeKind);
     appendSingleIfAbsent("primary-ref", resolvedInputs.targetPath);
@@ -1555,6 +1889,7 @@ function appendReviewInvokeDerivedArgs(argv, resolvedInputs) {
     appendMultiIfAbsent("filesystem-allowed-root", resolvedInputs.filesystemAllowedRoots);
     appendMultiIfAbsent("lens-id", resolvedInputs.resolvedLensIds);
     appendMultiIfAbsent("materialized-ref", resolvedInputs.resolvedTargetRefs);
+    appendMissingMulti("binding-note", resolvedInputs.bindingNotes);
     if (resolvedInputs.targetScopeKind === "bundle") {
         appendMultiIfAbsent("member-ref", resolvedInputs.resolvedTargetRefs.slice(1));
         if (typeof resolvedInputs.bundleKind === "string" &&
@@ -1569,7 +1904,7 @@ function appendReviewInvokeDerivedArgs(argv, resolvedInputs) {
     }
     return appended;
 }
-async function readOptionalReviewSummary(sessionRoot) {
+export async function readOptionalReviewSummary(sessionRoot) {
     const bindingPath = path.join(sessionRoot, "binding.yaml");
     const reviewRecordPath = path.join(sessionRoot, "review-record.yaml");
     const binding = (await fileExists(bindingPath))
@@ -1657,7 +1992,7 @@ function appendDirectoryListingConfigArgs(targetArgv, originalArgv, ontoConfig)
     }
     return result;
 }
-async function resolveReviewInvokeSetup(argv) {
+export async function resolveReviewInvokeSetup(argv) {
     rejectRemovedFlags(argv);
     const argvWithSessionId = ensureSessionIdArg(argv);
     const sessionId = requireString(readSingleOptionValueFromArgv(argvWithSessionId, "session-id"), "session-id");
@@ -1667,7 +2002,7 @@ async function resolveReviewInvokeSetup(argv) {
     const ontoConfig = ontoHome
         ? await resolveSettingsChain(ontoHome, projectRoot)
         : await readOntoConfig(projectRoot);
-    const resolvedInvokeInputs = await resolveReviewInvokeInputs(argvWithSessionId, ontoConfig, projectRoot, sessionId);
+    const resolvedInvokeInputs = await resolveReviewInvokeInputs(argvWithSessionId, ontoConfig, projectRoot, sessionId, ontoHome);
     const maxConcurrentLenses = Math.max(1, resolvedInvokeInputs.resolvedLensIds.length);
     const { optionTokens: argvWithoutPositionals } = splitArgvIntoOptionsAndPositionals(argvWithSessionId, [...KNOWN_INVOKE_ONLY_OPTION_NAMES, ...KNOWN_PASSTHROUGH_OPTION_NAMES], [...KNOWN_INVOKE_ONLY_FLAG_NAMES, ...KNOWN_PASSTHROUGH_FLAG_NAMES]);
     const normalizedStartArgv = appendReviewInvokeDerivedArgs(stripOptionsFromArgv(argvWithoutPositionals, [...KNOWN_INVOKE_ONLY_OPTION_NAMES], [...KNOWN_INVOKE_ONLY_FLAG_NAMES]), resolvedInvokeInputs);
@@ -1708,21 +2043,15 @@ async function resolveReviewInvokeSetup(argv) {
  * values written into the prepared session artifacts.
  */
 export async function reviewPrepareOnly(argv) {
-    const setup = await resolveReviewInvokeSetup(argv);
-    const startResult = await startReviewSession(setup.startArgv);
-    const sessionRoot = path.resolve(startResult.session_root);
-    const profile = setup.executionProfile;
-    return {
-        prepare_only: true,
-        session_root: sessionRoot,
-        request_text: setup.resolvedInvokeInputs.requestText,
-        execution_realization: profile.execution_realization,
-        host_runtime: profile.host_runtime,
-        review_mode: setup.resolvedInvokeInputs.reviewMode,
-    };
+    return prepareReviewInvocationArgv(argv);
 }
 export async function runReviewInvokeCli(argv) {
     const prepareOnly = hasOptionFlag(argv, "prepare-only");
+    if (!prepareOnly) {
+        const output = await runReviewInvocationArgv(argv);
+        console.log(JSON.stringify(output, null, 2));
+        return 0;
+    }
     const setup = await resolveReviewInvokeSetup(argv);
     const resolvedProjectRoot = path.resolve(readSingleOptionValueFromArgv(setup.startArgv, "project-root") ?? ".");
     const rawOntoHome = readSingleOptionValueFromArgv(setup.startArgv, "onto-home");
@@ -1944,6 +2273,7 @@ export async function runReviewInvokeCli(argv) {
             target: setup.resolvedInvokeInputs.requestedTarget,
             target_scope_kind: setup.resolvedInvokeInputs.targetScopeKind,
             domain: setup.resolvedInvokeInputs.domainFinalValue,
+            domain_selection_reason: setup.resolvedInvokeInputs.domainSelectionReason,
         },
         coverage: {
             planned_lens_count: setup.resolvedInvokeInputs.resolvedLensIds.length,
@@ -1963,6 +2293,7 @@ export async function runReviewInvokeCli(argv) {
         target: setup.resolvedInvokeInputs.requestedTarget,
         targetScopeKind: setup.resolvedInvokeInputs.targetScopeKind,
         domain: setup.resolvedInvokeInputs.domainFinalValue,
+        domainSelectionReason: setup.resolvedInvokeInputs.domainSelectionReason,
         status: recordStatus,
         deliberationStatus,
         reviewMode: setup.resolvedInvokeInputs.reviewMode,
@@ -1987,6 +2318,7 @@ export async function runReviewInvokeCli(argv) {
                 : null,
             domain_selection_required: setup.resolvedInvokeInputs.domainSelectionRequired,
             domain_selection_mode: setup.resolvedInvokeInputs.domainSelectionMode,
+            domain_selection_reason: setup.resolvedInvokeInputs.domainSelectionReason,
             domain_final_value: setup.resolvedInvokeInputs.domainFinalValue,
             review_mode: setup.resolvedInvokeInputs.reviewMode,
         },