onto-mcp 0.3.2 → 0.4.0

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

@@ -15,6 +15,8 @@ import { collectReviewInvocationArtifactRefs, prepareReviewInvocationRequest, ru
 import { completeReviewSession } from "../core-runtime/cli/complete-review-session.js";
 import { buildExecutorConfigFromRealization, } from "../core-runtime/cli/review-invoke.js";
 import { executeReviewPromptExecution, } from "../core-runtime/cli/run-review-prompt-execution.js";
+import { spawnRuntimeWatcherPane, } from "../core-runtime/cli/spawn-watcher.js";
+import { appendRuntimeStatusEventSync, } from "../core-runtime/observability/runtime-stream-observation.js";
 import { buildReviewPipelineExecutionLedger, } from "../core-runtime/review/pipeline-execution-ledger.js";
 import { buildReviewContinuationPlan, } from "../core-runtime/review/continuation-plan.js";
 export class ReviewContinuationError extends Error {
@@ -1766,6 +1768,7 @@ export function createOntoReviewCoreApi(options = {}) {
         },
         async runReview(request) {
             await validateRequestedDomainForDispatch(request, ontoHome);
+            const projectRoot = path.resolve(request.projectRoot);
             const requestHash = requestHashForReviewInput(request);
             const invocationId = `initial-${continuationAttemptId()}`;
             let progressSequence = 0;
@@ -1801,6 +1804,23 @@ export function createOntoReviewCoreApi(options = {}) {
                     return;
                 sessionRootResolved = true;
                 resolveSessionRoot(resolved);
+                appendRuntimeStatusEventSync({
+                    pipeline: "review",
+                    sessionRoot: resolved,
+                    sourceLabel: "onto.review",
+                    message: "review session observed",
+                    stageId: "start",
+                });
+                const watcherResult = spawnRuntimeWatcherPane(projectRoot, resolved, ontoHome);
+                appendRuntimeStatusEventSync({
+                    pipeline: "review",
+                    sessionRoot: resolved,
+                    sourceLabel: "runtime-watcher",
+                    message: watcherResult.spawned
+                        ? `watcher ${watcherResult.dry_run ? "detected" : "attached"} via ${watcherResult.mechanism}`
+                        : `watcher not attached: ${watcherResult.reason ?? "unknown reason"}`,
+                    stageId: "start",
+                });
                 activeAttemptWrite = (async () => {
                     const executionPlan = await readOptionalYaml(path.join(resolved, "execution-plan.yaml"));
                     await writeActiveAttemptStarted({
@@ -1819,6 +1839,16 @@ export function createOntoReviewCoreApi(options = {}) {
             const runnerProgressObserver = (event) => {
                 if (event.sessionRoot)
                     noteSessionRoot(event.sessionRoot);
+                const runtimeSessionRoot = event.sessionRoot ?? observedSessionRoot;
+                if (runtimeSessionRoot) {
+                    appendRuntimeStatusEventSync({
+                        pipeline: "review",
+                        sessionRoot: runtimeSessionRoot,
+                        sourceLabel: "onto.review",
+                        message: `${event.status}: ${event.message}`,
+                        stageId: event.phase,
+                    });
+                }
                 const stage = event.phase === "prepare"
                     ? "session_planned"
                     : event.phase === "execute"
@@ -2025,6 +2055,23 @@ export function createOntoReviewCoreApi(options = {}) {
                 expected: projectRoot,
                 actual: sessionMetadata.project_root,
             });
+            appendRuntimeStatusEventSync({
+                pipeline: "review",
+                sessionRoot: resolvedSessionRoot,
+                sourceLabel: "onto.review_continue",
+                message: "review continuation starting",
+                stageId: "continue",
+            });
+            const continuationWatcherResult = spawnRuntimeWatcherPane(projectRoot, resolvedSessionRoot, ontoHome);
+            appendRuntimeStatusEventSync({
+                pipeline: "review",
+                sessionRoot: resolvedSessionRoot,
+                sourceLabel: "runtime-watcher",
+                message: continuationWatcherResult.spawned
+                    ? `watcher ${continuationWatcherResult.dry_run ? "detected" : "attached"} via ${continuationWatcherResult.mechanism}`
+                    : `watcher not attached: ${continuationWatcherResult.reason ?? "unknown reason"}`,
+                stageId: "continue",
+            });
             const artifactRefs = await collectArtifactRefs(resolvedSessionRoot);
             const executionPlan = await readOptionalYaml(path.join(resolvedSessionRoot, "execution-plan.yaml"));
             if (!executionPlan) {

package/dist/core-runtime/cli/codex-review-unit-executor.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import { spawn } from "node:child_process";
 import { parseArgs } from "node:util";
 import { pathToFileURL } from "node:url";
+import { appendRuntimeStreamChunkSync, appendRuntimeStreamEventSync, } from "../observability/runtime-stream-observation.js";
 function requireString(value, optionName) {
     if (typeof value !== "string" || value.length === 0) {
         throw new Error(`Missing required option --${optionName}`);
@@ -40,7 +41,7 @@ Authoritative prompt packet follows:
 ${packetText}
 `;
 }
-async function runCodexWorker(projectRoot, boundedPrompt, outputPath, model, sandboxMode, reasoningEffort, configOverrides, unitId) {
+async function runCodexWorker(projectRoot, boundedPrompt, outputPath, model, sandboxMode, reasoningEffort, configOverrides, unitId, unitKind, sessionRoot) {
     const codexArgs = [
         "exec",
         "-C",
@@ -65,6 +66,22 @@ async function runCodexWorker(projectRoot, boundedPrompt, outputPath, model, san
         cwd: projectRoot,
         stdio: ["pipe", "pipe", "pipe"],
     });
+    const runtimeSourceBase = {
+        kind: "process",
+        label: `codex:${unitId}`,
+        unitId,
+        stageId: unitKind,
+    };
+    const runtimeSource = child.pid !== undefined
+        ? { ...runtimeSourceBase, processId: child.pid }
+        : runtimeSourceBase;
+    appendRuntimeStreamEventSync({
+        pipeline: "review",
+        sessionRoot,
+        source: runtimeSource,
+        stream: "status",
+        message: `codex worker started: ${unitKind} ${unitId}`,
+    });
     // Real-time tee to disk: each codex stdout/stderr chunk is appended to
     // the running log under the lens output directory so a watcher pane
     // can `tail -f` it live. The in-memory buffers remain for final error
@@ -90,11 +107,23 @@ async function runCodexWorker(projectRoot, boundedPrompt, outputPath, model, san
         stdout += String(chunk);
         if (runningLogStream)
             runningLogStream.write(chunk);
+        appendRuntimeStreamChunkSync({
+            pipeline: "review",
+            sessionRoot,
+            source: runtimeSource,
+            stream: "stdout",
+        }, chunk);
     });
     child.stderr.on("data", (chunk) => {
         stderr += String(chunk);
         if (runningLogStream)
             runningLogStream.write(chunk);
+        appendRuntimeStreamChunkSync({
+            pipeline: "review",
+            sessionRoot,
+            source: runtimeSource,
+            stream: "stderr",
+        }, chunk);
     });
     child.stdin.write(boundedPrompt);
     child.stdin.end();
@@ -109,6 +138,13 @@ async function runCodexWorker(projectRoot, boundedPrompt, outputPath, model, san
         });
         child.on("close", (code) => resolve(code ?? 1));
     });
+    appendRuntimeStreamEventSync({
+        pipeline: "review",
+        sessionRoot,
+        source: runtimeSource,
+        stream: "status",
+        message: `codex worker exited: ${unitKind} ${unitId} code=${exitCode}`,
+    });
     // Flush the stream before deciding cleanup so tail -f readers see final
     // bytes. ENV-AFTER line is written before close for parse parity with
     // the codex-nested running log.
@@ -186,6 +222,7 @@ export async function runCodexReviewUnitExecutorCli(argv) {
     const projectRoot = path.resolve(requireString(values["project-root"], "project-root"));
     const unitId = requireString(values["unit-id"], "unit-id");
     const unitKind = requireString(values["unit-kind"], "unit-kind");
+    const sessionRoot = path.resolve(requireString(values["session-root"], "session-root"));
     const packetPath = path.resolve(requireString(values["packet-path"], "packet-path"));
     const outputPath = path.resolve(requireString(values["output-path"], "output-path"));
     // Review Recovery PR-1 (R1 observability symmetry). The codex executor does
@@ -202,7 +239,7 @@ export async function runCodexReviewUnitExecutorCli(argv) {
     const packetText = await fs.readFile(packetPath, "utf8");
     const boundedPrompt = buildBoundedPrompt(packetPath, packetText, outputPath, unitId, unitKind);
     await fs.mkdir(path.dirname(outputPath), { recursive: true });
-    await runCodexWorker(projectRoot, boundedPrompt, outputPath, values.model, values["sandbox-mode"], values["reasoning-effort"], values["config-override"], unitId);
+    await runCodexWorker(projectRoot, boundedPrompt, outputPath, values.model, values["sandbox-mode"], values["reasoning-effort"], values["config-override"], unitId, unitKind, sessionRoot);
     const outputText = await fs.readFile(outputPath, "utf8");
     if (outputText.trim().length === 0) {
         throw new Error(`Codex executor produced empty output: ${outputPath}`);

package/dist/core-runtime/cli/complete-review-session.js

@@ -46,8 +46,8 @@ export async function completeReviewSession(argv) {
     return {
         session_root: sessionRoot,
         bounded_complete_steps: [
-            "review:render-final-output",
-            "review:finalize-session",
+            "render_review_final_output",
+            "assemble_review_record",
         ],
     };
 }

package/dist/core-runtime/cli/mock-review-unit-executor.js

@@ -73,7 +73,7 @@ deliberation_status: performed
 - Replace the mock executor with a real ContextIsolatedReasoningUnit realization.
 
 ### Recommendations
-- Keep MCP review connected to \`review:start-session -> review:run-prompt-execution -> review:complete-session\`.
+- Keep MCP review connected to the start-session -> prompt-execution -> completion runtime.
 
 ### Unique Finding Tagging
 - mock-runner-generated

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

@@ -1634,14 +1634,14 @@ async function resolveReviewInvokeInputs(argv, ontoConfig, projectRoot, sessionI
     }
     if (!bundleRequested &&
         (typeof requestedTarget !== "string" || requestedTarget.length === 0)) {
-        throw new Error("Missing review target. Use `npm run review:invoke -- <target> \"<intent>\"` or pass --requested-target.");
+        throw new Error("Missing review target. Pass <target> \"<intent>\" or pass --requested-target.");
     }
     const MAX_REQUEST_TEXT_LENGTH = 2000;
     let requestText = readSingleOptionValueFromArgv(argv, "request-text") ??
         readSingleOptionValueFromArgv(argv, "intent-summary") ??
         parsedPositionals.intentText;
     if (typeof requestText !== "string" || requestText.length === 0) {
-        throw new Error("Missing review intent. Use `npm run review:invoke -- <target> \"<intent>\"` or pass --request-text.");
+        throw new Error("Missing review intent. Pass <target> \"<intent>\" or pass --request-text.");
     }
     if (requestText.length > MAX_REQUEST_TEXT_LENGTH) {
         console.warn(`[onto] Request text truncated from ${requestText.length} to ${MAX_REQUEST_TEXT_LENGTH} characters.`);
@@ -1948,14 +1948,14 @@ function rejectRemovedFlags(argv) {
         throwRetiredInput("--max-concurrent-lenses", "--max-concurrent-lenses is not supported. Review runs all selected lenses in parallel.");
     }
     if (hasOptionFlag(argv, "claude")) {
-        throwRetiredInput("--claude", "--claude is not supported by review:invoke. Use the MCP review path or project settings.");
+        throwRetiredInput("--claude", "--claude is not supported by the review runtime. Use the MCP review path or project settings.");
     }
     for (const removed of ["host-runtime", "execution-realization", "execution-mode"]) {
         const optionToken = `--${removed}`;
         const present = hasOptionFlag(argv, removed) ||
             argv.some((token) => token.startsWith(`${optionToken}=`));
         if (present) {
-            throwRetiredInput(optionToken, `--${removed} is not supported by review:invoke. Use .onto/settings.json for execution profile selection.`);
+            throwRetiredInput(optionToken, `--${removed} is not supported by the review runtime. Use .onto/settings.json for execution profile selection.`);
         }
     }
 }
@@ -2108,7 +2108,7 @@ export async function runReviewInvokeCli(argv) {
             console.log(`[review runner] live watcher ${action} ${watcherResult.mechanism}`);
         }
         else {
-            console.log(`[review runner] live progress: open another terminal and run \`npm run review:watch -- "${sessionRoot}"\`` +
+            console.log(`[review runner] live progress: open another terminal and run \`bash scripts/onto-review-watch.sh "${sessionRoot}"\`` +
                 (watcherResult.reason ? ` (${watcherResult.reason})` : ""));
         }
     }
@@ -2157,9 +2157,9 @@ export async function runReviewInvokeCli(argv) {
     console.log("[review invoke] completed 3/3 record assembly");
     const reviewSummary = await readOptionalReviewSummary(sessionRoot);
     const boundedInvokeSteps = [
-        "review:start-session",
-        "review:run-prompt-execution",
-        "review:complete-session",
+        "start_review_session",
+        "run_review_prompt_execution",
+        "complete_review_session",
     ];
     const finalRoute = buildReviewExecutionRoute(effectiveReviewExecutionProfile);
     const routeProfile = {
@@ -2169,7 +2169,7 @@ export async function runReviewInvokeCli(argv) {
         review_execution_profile: effectiveReviewExecutionProfile,
     };
     const routeSummary = {
-        combined_entrypoint: "review:invoke",
+        combined_entrypoint: "review_invocation",
         bounded_invoke_steps: [...boundedInvokeSteps],
         execution_realization: routeProfile.execution_realization,
         host_runtime: routeProfile.host_runtime,

package/dist/core-runtime/cli/run-review-prompt-execution.js

@@ -15,6 +15,7 @@ import { printOntoReleaseChannelNotice } from "../release-channel/release-channe
 import { executeReviewViaCodexNested } from "./codex-nested-dispatch.js";
 import { ReviewStructuredFailureError, writeAndThrowStructuredFailureRecord, } from "../review/failure-records.js";
 import { assertReviewExecutionPlanSessionBoundary, } from "../review/execution-plan-boundary.js";
+import { appendRuntimeStreamChunkSync, appendRuntimeStreamEventSync, } from "../observability/runtime-stream-observation.js";
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -128,11 +129,9 @@ function requireString(value, optionName) {
 /** Default stagger delay between successive lens dispatches (ms).
  *  Spreads initial burst to avoid thundering-herd on the external API. */
 function defaultStaggerDelayMsForExecutorConfig(executorConfig) {
-    if (executorConfig.bin === "npm" || executorConfig.bin.endsWith("npm.cmd")) {
-        if (executorConfig.args.includes("review:codex-unit-executor")) {
-            // codex executor spawns an external process → API request per lens
-            return 1500;
-        }
+    if (executorConfig.args.some((arg) => arg.includes("codex-review-unit-executor"))) {
+        // codex executor spawns an external process -> API request per lens
+        return 1500;
     }
     return 0;
 }
@@ -258,13 +257,41 @@ async function invokeExecutor(executorConfig, projectRoot, sessionRoot, dispatch
             ...(process.env.ONTO_HOME ? { ONTO_HOME: process.env.ONTO_HOME } : {}),
         },
     });
+    const runtimeSourceBase = {
+        kind: "process",
+        label: `${dispatch.unit_kind}:${dispatch.unit_id}`,
+        unitId: dispatch.unit_id,
+        stageId: dispatch.unit_kind,
+    };
+    const runtimeSource = child.pid !== undefined
+        ? { ...runtimeSourceBase, processId: child.pid }
+        : runtimeSourceBase;
+    appendRuntimeStreamEventSync({
+        pipeline: "review",
+        sessionRoot,
+        source: runtimeSource,
+        stream: "status",
+        message: `executor started: ${dispatch.unit_kind} ${dispatch.unit_id}`,
+    });
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (chunk) => {
         stdout += String(chunk);
+        appendRuntimeStreamChunkSync({
+            pipeline: "review",
+            sessionRoot,
+            source: runtimeSource,
+            stream: "stdout",
+        }, chunk);
     });
     child.stderr.on("data", (chunk) => {
         stderr += String(chunk);
+        appendRuntimeStreamChunkSync({
+            pipeline: "review",
+            sessionRoot,
+            source: runtimeSource,
+            stream: "stderr",
+        }, chunk);
     });
     let timedOut = false;
     let forceKillTimer = null;
@@ -302,6 +329,13 @@ async function invokeExecutor(executorConfig, projectRoot, sessionRoot, dispatch
             resolve(code ?? 1);
         });
     });
+    appendRuntimeStreamEventSync({
+        pipeline: "review",
+        sessionRoot,
+        source: runtimeSource,
+        stream: "status",
+        message: `executor exited: ${dispatch.unit_kind} ${dispatch.unit_id} code=${exitCode}`,
+    });
     if (timedOut) {
         await removeFileIfExists(dispatch.output_path);
         throw new ReviewUnitTimeoutError(dispatch.unit_id, timeoutMs);