onto-mcp 0.4.7 → 0.4.8

package/dist/core-api/review-api.js

@@ -19,7 +19,7 @@ import { synthesisLedgerPath, synthesisWorkItemsPath, } from "../core-runtime/re
 import { readValidatedReviewRecord } from "../core-runtime/review/review-record-validation.js";
 import { readReviewResultClassification } from "../core-runtime/review/review-result-classification.js";
 import { REVIEW_EXECUTION_STEP_IDS, REVIEW_PROGRESS_STEPS, REVIEW_PROGRESS_TOTAL_STEPS, reviewProgressStepById, reviewProgressStepIdFromHalt, } from "../core-runtime/review/review-progress-contract.js";
-import { collectReviewInvocationArtifactRefs, prepareReviewInvocationRequest, runReviewInvocation, } from "../core-runtime/review/review-invocation-runner.js";
+import { collectReviewInvocationArtifactRefs, prepareReviewInvocationRequest, runReviewInvocation, } from "../core-runtime/cli/review-invocation-runner.js";
 import { completeReviewSession } from "../core-runtime/cli/complete-review-session.js";
 import { buildExecutorConfigFromRealization, ensureProviderRouteReadyForDispatch, resolveExecutorConfig, } from "../core-runtime/cli/review-invoke.js";
 import { writeAndThrowStructuredFailureRecord, } from "../core-runtime/review/failure-records.js";

package/dist/core-runtime/{review → cli}/review-invocation-runner.js

@@ -1,10 +1,14 @@
+#!/usr/bin/env node
 import path from "node:path";
-import { completeReviewSession } from "../cli/complete-review-session.js";
-import { ensureProviderRouteReadyForDispatch, inferExecutorRealization, readOptionalReviewSummary, readReviewResultClosureSummary, readReviewResultExplanationSummary, resolveExecutorConfig, resolveReviewInvokeSetup, } from "../cli/review-invoke.js";
-import { executeReviewPromptExecution } from "../cli/run-review-prompt-execution.js";
-import { startReviewSession } from "../cli/start-review-session.js";
-import { buildReviewExecutionRoute, buildReviewRuntimeRouteArtifactProjection, } from "./review-execution-route.js";
-import { fileExists, normalizeDomainValue, readSingleOptionValueFromArgv, } from "./review-artifact-utils.js";
+import { pathToFileURL } from "node:url";
+import { completeReviewSession } from "./complete-review-session.js";
+import { ensureProviderRouteReadyForDispatch, inferExecutorRealization, readOptionalReviewSummary, readReviewResultClosureSummary, readReviewResultExplanationSummary, resolveExecutorConfig, resolveReviewInvokeSetup, concurrencyStrategyFor, renderReviewResultOverview, renderReviewStartPreview, requireString, } from "./review-invoke.js";
+import { executeReviewPromptExecution } from "./run-review-prompt-execution.js";
+import { startReviewSession } from "./start-review-session.js";
+import { spawnWatcherPane } from "./spawn-watcher.js";
+import { printOntoReleaseChannelNotice } from "../release-channel/release-channel.js";
+import { buildReviewExecutionRoute, buildReviewRuntimeRouteArtifactProjection, } from "../review/review-execution-route.js";
+import { fileExists, normalizeDomainValue, hasOptionFlag, readSingleOptionValueFromArgv, } from "../review/review-artifact-utils.js";
 export function appendReviewInvocationRequestArgs(args, request, options) {
     if (request.domain && request.noDomain) {
         throw new Error("Use either domain or noDomain, not both.");
@@ -625,3 +629,329 @@ async function projectReviewInvocationCliOutput(args) {
         },
     };
 }
+/**
+ * Runs review preparation and returns the result directly (no console output).
+ *
+ * The execution_realization / host_runtime in the returned result mirror the
+ * values written into the prepared session artifacts.
+ */
+export async function reviewPrepareOnly(argv) {
+    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");
+    const resolvedOntoHome = rawOntoHome ? path.resolve(rawOntoHome) : undefined;
+    const noWatch = hasOptionFlag(argv, "no-watch");
+    const hasExplicitExecutorBinOverride = readSingleOptionValueFromArgv(argv, "executor-bin") !== undefined ||
+        readSingleOptionValueFromArgv(argv, "synthesize-executor-bin") !== undefined;
+    const effectiveReviewExecutionProfile = setup.executionProfile.review_execution_profile;
+    const plannedSessionId = requireString(readSingleOptionValueFromArgv(setup.startArgv, "session-id"), "session-id");
+    const plannedSessionRoot = path.join(resolvedProjectRoot, ".onto", "review", plannedSessionId);
+    console.log(renderReviewStartPreview({
+        projectRoot: resolvedProjectRoot,
+        sessionRoot: plannedSessionRoot,
+        setup,
+        reviewExecutionProfile: effectiveReviewExecutionProfile,
+    }));
+    console.log("[review invoke] step 1/3 start session");
+    const startResult = await startReviewSession(setup.startArgv);
+    if (prepareOnly) {
+        const sessionRoot = path.resolve(startResult.session_root);
+        const profile = setup.executionProfile;
+        const result = {
+            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,
+        };
+        console.log(JSON.stringify(result, null, 2));
+        return 0;
+    }
+    const sessionRoot = path.resolve(startResult.session_root);
+    // Auto-attach the live watcher pane AFTER session creation so the watcher
+    // receives the exact session-root as an explicit argument. Prior behaviour
+    // spawned the watcher before startReviewSession and relied on the shared
+    // `.onto/review/.latest-session` pointer — but that pointer is a project-
+    // global single file, so concurrent review sessions (two or more
+    // review invocations running in parallel) caused each
+    // watcher to latch onto whichever session wrote `.latest-session` last.
+    // Passing sessionRoot explicitly eliminates that race.
+    if (!noWatch) {
+        const watcherResult = spawnWatcherPane(resolvedProjectRoot, sessionRoot, resolvedOntoHome);
+        if (watcherResult.spawned) {
+            // Distinguish dry-run (mechanism detected, no osascript/tmux invoked)
+            // from real attach (actual side pane / split / tab opened). Log
+            // readers need both to verify "did the pane appear?" without
+            // conflating it with "did detection logic reach the right branch?".
+            const action = watcherResult.dry_run
+                ? "detection via"
+                : "attached via";
+            console.log(`[review runner] live watcher ${action} ${watcherResult.mechanism}`);
+        }
+        else {
+            console.log(`[review runner] live progress: open another terminal and run \`bash scripts/onto-review-watch.sh "${sessionRoot}"\`` +
+                (watcherResult.reason ? ` (${watcherResult.reason})` : ""));
+        }
+    }
+    const resolvedRequestText = setup.resolvedInvokeInputs.requestText;
+    await ensureProviderRouteReadyForDispatch({
+        sessionRoot,
+        executionPlanPath: path.join(sessionRoot, "execution-plan.yaml"),
+        reviewExecutionProfile: effectiveReviewExecutionProfile,
+    });
+    const defaultExecutorConfig = resolveExecutorConfig(argv, "", setup.ontoConfig, setup.ontoHome, hasExplicitExecutorBinOverride
+        ? undefined
+        : setup.executionProfile.review_execution_profile, "lens");
+    const teamleadExecutorConfig = resolveExecutorConfig(argv, "", setup.ontoConfig, setup.ontoHome, hasExplicitExecutorBinOverride
+        ? undefined
+        : setup.executionProfile.review_execution_profile, "teamlead");
+    const synthesizeExecutorConfig = resolveExecutorConfig(argv, "synthesize-", setup.ontoConfig, setup.ontoHome, hasExplicitExecutorBinOverride
+        ? undefined
+        : setup.executionProfile.review_execution_profile, "synthesize");
+    console.log("[review invoke] step 2/3 prompt execution");
+    const promptExecutionResult = await executeReviewPromptExecution({
+        projectRoot: resolvedProjectRoot,
+        sessionRoot,
+        defaultExecutorConfig,
+        ...(teamleadExecutorConfig.bin === defaultExecutorConfig.bin &&
+            JSON.stringify(teamleadExecutorConfig.args) ===
+                JSON.stringify(defaultExecutorConfig.args)
+            ? {}
+            : { teamleadExecutorConfig }),
+        ...(synthesizeExecutorConfig.bin === defaultExecutorConfig.bin &&
+            JSON.stringify(synthesizeExecutorConfig.args) ===
+                JSON.stringify(defaultExecutorConfig.args)
+            ? {}
+            : { synthesizeExecutorConfig }),
+        reviewExecutionProfile: effectiveReviewExecutionProfile,
+        ontoConfig: setup.ontoConfig,
+    });
+    console.log("[review invoke] step 3/3 record assembly");
+    await completeReviewSession([
+        "--project-root",
+        resolvedProjectRoot,
+        "--session-root",
+        sessionRoot,
+        "--request-text",
+        resolvedRequestText,
+    ]);
+    console.log("[review invoke] completed 3/3 record assembly");
+    const reviewSummary = await readOptionalReviewSummary(sessionRoot);
+    const boundedInvokeSteps = [
+        "start_review_session",
+        "run_review_prompt_execution",
+        "complete_review_session",
+    ];
+    const finalRoute = buildReviewExecutionRoute(effectiveReviewExecutionProfile);
+    const routeProfile = {
+        ...setup.executionProfile,
+        execution_realization: finalRoute.execution_realization,
+        host_runtime: finalRoute.artifact_host_runtime,
+        review_execution_profile: effectiveReviewExecutionProfile,
+    };
+    const routeSummary = {
+        combined_entrypoint: "review_invocation",
+        bounded_invoke_steps: [...boundedInvokeSteps],
+        execution_realization: routeProfile.execution_realization,
+        host_runtime: routeProfile.host_runtime,
+        review_execution_profile: {
+            mode: routeProfile.review_execution_profile.mode,
+            teamlead_seat: routeProfile.review_execution_profile.teamlead.seat,
+            lens_seat: routeProfile.review_execution_profile.lens.seat,
+            synthesize_seat: routeProfile.review_execution_profile.synthesize.seat,
+            worker_executor: routeProfile.review_execution_profile.worker_executor,
+            deliberation: routeProfile.review_execution_profile.deliberation,
+            runtime_route: buildReviewRuntimeRouteArtifactProjection(finalRoute),
+            ...(routeProfile.review_execution_profile.model
+                ? { model: routeProfile.review_execution_profile.model }
+                : {}),
+            ...(routeProfile.review_execution_profile.effort
+                ? { effort: routeProfile.review_execution_profile.effort }
+                : {}),
+            ...(routeProfile.review_execution_profile.service_tier
+                ? { service_tier: routeProfile.review_execution_profile.service_tier }
+                : {}),
+            ...(routeProfile.review_execution_profile.retry
+                ? { retry: routeProfile.review_execution_profile.retry }
+                : {}),
+        },
+        review_mode: setup.resolvedInvokeInputs.reviewMode,
+        max_concurrent_lenses: setup.maxConcurrentLenses,
+        concurrency_strategy: concurrencyStrategyFor({
+            plannedLensCount: setup.resolvedInvokeInputs.resolvedLensIds.length,
+            maxConcurrentLenses: setup.maxConcurrentLenses,
+        }),
+        synthesize_waits_for_all_lenses: true,
+    };
+    const finalOutputPath = reviewSummary.binding?.final_output_path ?? path.join(sessionRoot, "final-output.md");
+    const reviewRecordPath = reviewSummary.binding?.review_record_path ?? path.join(sessionRoot, "review-record.yaml");
+    const executionResultPath = reviewSummary.binding?.execution_result_path ?? path.join(sessionRoot, "execution-result.yaml");
+    const reviewRunManifestPath = path.join(sessionRoot, "review-run-manifest.yaml");
+    const participatingLensIds = reviewSummary.reviewRecord?.participating_lens_ids ??
+        promptExecutionResult.participating_lens_ids;
+    const degradedLensIds = reviewSummary.reviewRecord?.degraded_lens_ids ??
+        promptExecutionResult.degraded_lens_ids;
+    const recordStatus = reviewSummary.reviewRecord?.record_status ??
+        reviewSummary.executionResult?.execution_status ??
+        null;
+    const deliberationStatus = reviewSummary.reviewRecord?.deliberation_status ??
+        reviewSummary.executionResult?.deliberation_status ??
+        null;
+    const haltSummary = reviewSummary.executionResult?.halt_reason || promptExecutionResult.halt_reason
+        ? {
+            reason: reviewSummary.executionResult?.halt_reason ??
+                promptExecutionResult.halt_reason ??
+                null,
+            phase: reviewSummary.executionResult?.halt_phase ??
+                promptExecutionResult.halt_phase ??
+                null,
+            unit_id: reviewSummary.executionResult?.halt_unit_id ??
+                promptExecutionResult.halt_unit_id ??
+                null,
+            unit_kind: reviewSummary.executionResult?.halt_unit_kind ??
+                promptExecutionResult.halt_unit_kind ??
+                null,
+            lens_id: reviewSummary.executionResult?.halt_lens_id ??
+                promptExecutionResult.halt_lens_id ??
+                null,
+        }
+        : null;
+    const executionSummary = {
+        status: recordStatus,
+        deliberation_status: deliberationStatus,
+        halt: haltSummary,
+        review_mode: setup.resolvedInvokeInputs.reviewMode,
+        lens: {
+            participating_count: participatingLensIds.length,
+            degraded_count: degradedLensIds.length,
+            participating_lens_ids: participatingLensIds,
+            degraded_lens_ids: degradedLensIds,
+        },
+        executor: {
+            max_concurrent_lenses: setup.maxConcurrentLenses,
+            concurrency_strategy: concurrencyStrategyFor({
+                plannedLensCount: setup.resolvedInvokeInputs.resolvedLensIds.length,
+                maxConcurrentLenses: setup.maxConcurrentLenses,
+            }),
+            realization: inferExecutorRealization(defaultExecutorConfig),
+            profile: routeSummary.review_execution_profile,
+        },
+    };
+    const artifactRefs = {
+        session_root: sessionRoot,
+        final_output: finalOutputPath,
+        review_record: reviewRecordPath,
+        execution_result: executionResultPath,
+        review_run_manifest: reviewRunManifestPath,
+    };
+    const closureSummary = await readReviewResultClosureSummary(sessionRoot);
+    const explanationSummary = await readReviewResultExplanationSummary(finalOutputPath);
+    const resultOverview = {
+        outcome: {
+            status: recordStatus,
+            deliberation_status: deliberationStatus,
+            halt: haltSummary,
+            review_mode: setup.resolvedInvokeInputs.reviewMode,
+        },
+        scope: {
+            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,
+            participating_lens_count: participatingLensIds.length,
+            degraded_lens_count: degradedLensIds.length,
+            participating_lens_ids: participatingLensIds,
+            degraded_lens_ids: degradedLensIds,
+        },
+        explanation: {
+            final_review_result: explanationSummary.final_review_result,
+            boundary_notes: explanationSummary.boundary_notes,
+        },
+        issues: closureSummary,
+        artifacts: artifactRefs,
+    };
+    console.log(renderReviewResultOverview({
+        projectRoot: resolvedProjectRoot,
+        target: setup.resolvedInvokeInputs.requestedTarget,
+        targetScopeKind: setup.resolvedInvokeInputs.targetScopeKind,
+        domain: setup.resolvedInvokeInputs.domainFinalValue,
+        domainSelectionReason: setup.resolvedInvokeInputs.domainSelectionReason,
+        status: recordStatus,
+        deliberationStatus,
+        reviewMode: setup.resolvedInvokeInputs.reviewMode,
+        plannedLensIds: setup.resolvedInvokeInputs.resolvedLensIds,
+        participatingLensIds,
+        degradedLensIds,
+        closureSummary,
+        explanationSummary,
+        artifactRefs,
+    }));
+    console.log(JSON.stringify({
+        summary: executionSummary,
+        result_overview: resultOverview,
+        entrypoint_plan: {
+            entrypoint: "review",
+            target: setup.resolvedInvokeInputs.requestedTarget,
+            target_scope_kind: setup.resolvedInvokeInputs.targetScopeKind,
+            resolved_target_refs: setup.resolvedInvokeInputs.resolvedTargetRefs,
+            request_text: resolvedRequestText,
+            requested_domain_token: setup.resolvedInvokeInputs.requestedDomainToken.length > 0
+                ? setup.resolvedInvokeInputs.requestedDomainToken
+                : 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,
+        },
+        route_summary: routeSummary,
+        artifacts: artifactRefs,
+        review_result: {
+            session_root: sessionRoot,
+            final_output_path: finalOutputPath,
+            review_record_path: reviewRecordPath,
+            execution_result_path: executionResultPath,
+            review_run_manifest_path: reviewRunManifestPath,
+            record_status: recordStatus,
+            deliberation_status: deliberationStatus,
+            halt_reason: haltSummary?.reason ?? null,
+            halt_phase: haltSummary?.phase ?? null,
+            halt_unit_id: haltSummary?.unit_id ?? null,
+            halt_unit_kind: haltSummary?.unit_kind ?? null,
+            halt_lens_id: haltSummary?.lens_id ?? null,
+            participating_lens_ids: participatingLensIds,
+            degraded_lens_ids: degradedLensIds,
+            summary: executionSummary,
+        },
+        bounded_invoke_steps: [...boundedInvokeSteps],
+        completion: {
+            status: recordStatus,
+            final_output_path: finalOutputPath,
+            review_record_path: reviewRecordPath,
+        },
+    }, null, 2));
+    return 0;
+}
+async function main() {
+    await printOntoReleaseChannelNotice();
+    return runReviewInvokeCli(process.argv.slice(2));
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    main().then((exitCode) => process.exit(exitCode), (error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+}