onto-mcp 0.3.0 → 0.3.2

package/dist/mcp/server.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
-import fs from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-import { createOntoReviewCoreApi, } from "../core-api/review-api.js";
+import { createOntoReviewCoreApi, ReviewContinuationError, } from "../core-api/review-api.js";
 import { createOntoReconstructCoreApi, } from "../core-api/reconstruct-api.js";
 import { OntoSettingsValidationError, UnsupportedOntoConfigFilesError, } from "../core-runtime/discovery/settings-chain.js";
 import { readOntoVersion } from "../core-runtime/release-channel/release-channel.js";
 import { createStructuredFailureRecord, ReviewStructuredFailureError, } from "../core-runtime/review/failure-records.js";
 import { buildReviewRouteVisibilityFromFailure, } from "../core-runtime/review/route-visibility.js";
 import { fileExists, readYamlDocument } from "../core-runtime/review/review-artifact-utils.js";
-import { OntoListDomainsToolInputSchema, OntoListSourceProfilesToolInputSchema, OntoObserveSourceToolInputSchema, OntoPrepareReviewToolInputSchema, OntoReconstructSessionInputSchema, OntoReconstructToolInputSchema, OntoReviewSessionInputSchema, OntoReviewToolInputSchema, OntoValidateReconstructDirectiveToolInputSchema, } from "./tool-schemas.js";
+import { isPathInsideRoot, realpathIfExists, } from "../core-runtime/path-boundary.js";
+import { OntoListDomainsToolInputSchema, OntoListSourceProfilesToolInputSchema, OntoObserveSourceToolInputSchema, OntoPrepareReviewToolInputSchema, OntoReconstructSessionInputSchema, OntoReconstructToolInputSchema, OntoReviewCancelToolInputSchema, OntoReviewContinueToolInputSchema, OntoReviewResultInputSchema, OntoReviewStatusInputSchema, OntoReviewToolInputSchema, OntoValidateReconstructDirectiveToolInputSchema, } from "./tool-schemas.js";
 const reviewApi = createOntoReviewCoreApi();
 const reconstructApi = createOntoReconstructCoreApi();
 const REVIEW_INPUT_SCHEMA = {
@@ -87,6 +87,10 @@ const REVIEW_INPUT_SCHEMA = {
             type: "boolean",
             description: "When true, materialize artifacts without executing lens units.",
         },
+        returnRunningAfterMs: {
+            type: "number",
+            description: "Optional synchronous wait budget in milliseconds. When exceeded after session planning, onto.review returns a running handle and background execution continues.",
+        },
     },
 };
 const SESSION_INPUT_SCHEMA = {
@@ -104,6 +108,101 @@ const SESSION_INPUT_SCHEMA = {
         },
     },
 };
+const REVIEW_STATUS_INPUT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        sessionRoot: {
+            type: "string",
+            description: "Absolute or project-relative review session root. Omit only when latest=true.",
+        },
+        projectRoot: {
+            type: "string",
+            description: "Project root that owns the review session. Defaults to the MCP server working directory.",
+        },
+        latest: {
+            type: "boolean",
+            description: "When true, recover the newest matching review session under projectRoot.",
+        },
+        target: {
+            type: "string",
+            description: "Optional latest-session target filter.",
+        },
+        domain: {
+            type: "string",
+            description: "Optional latest-session canonical or alias domain filter.",
+        },
+        requestHash: {
+            type: "string",
+            description: "Optional latest-session request hash filter returned by a run handle.",
+        },
+        limit: {
+            type: "number",
+            description: "Maximum latest-session matches to include. Defaults to 5.",
+        },
+    },
+};
+const REVIEW_RESULT_INPUT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: ["sessionRoot"],
+    properties: {
+        ...(SESSION_INPUT_SCHEMA.properties),
+        projectionLevel: {
+            type: "string",
+            enum: ["compact", "standard", "full"],
+            description: "Result projection size. compact omits final output text and ReviewRecord; full includes complete artifacts.",
+        },
+    },
+};
+const REVIEW_CONTINUE_INPUT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: ["sessionRoot"],
+    properties: {
+        sessionRoot: {
+            type: "string",
+            description: "Absolute or project-relative review session root.",
+        },
+        projectRoot: {
+            type: "string",
+            description: "Project root that owns the review session. Defaults to the MCP server working directory.",
+        },
+        targetUnits: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional current frontier unit ids or public aliases such as lens:logic and deliberation:logic. Omit to use the full ledger-derived first untrusted frontier.",
+        },
+        requestText: {
+            type: "string",
+            description: "Optional original request text for final ReviewRecord assembly when the session was only prepared.",
+        },
+        executorRealization: {
+            type: "string",
+            enum: ["codex", "mock", "ts_inline_http"],
+            description: "Executor realization for resumed units. Required for prepared sessions that have no prior review-run-manifest.",
+        },
+    },
+};
+const REVIEW_CANCEL_INPUT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: ["sessionRoot"],
+    properties: {
+        sessionRoot: {
+            type: "string",
+            description: "Absolute or project-relative review session root.",
+        },
+        projectRoot: {
+            type: "string",
+            description: "Project root that owns the review session. Defaults to the MCP server working directory.",
+        },
+        reason: {
+            type: "string",
+            description: "Optional cancellation reason recorded in the session.",
+        },
+    },
+};
 const LIST_DOMAINS_INPUT_SCHEMA = {
     type: "object",
     additionalProperties: false,
@@ -160,8 +259,6 @@ const RECONSTRUCT_INPUT_SCHEMA = {
     required: [
         "targetRefs",
         "intent",
-        "semanticAuthorRealization",
-        "confirmationProviderRealization",
     ],
     properties: {
         targetRefs: {
@@ -193,13 +290,13 @@ const RECONSTRUCT_INPUT_SCHEMA = {
         },
         semanticAuthorRealization: {
             type: "string",
-            enum: ["mock"],
-            description: "Explicit semantic author realization. Only mock is currently wired; host/direct-call authoring is not yet exposed.",
+            enum: ["mock", "direct_call"],
+            description: "Explicit semantic author realization. direct_call uses configured llm provider; mock is a test/fixture realization.",
         },
         confirmationProviderRealization: {
             type: "string",
-            enum: ["mock"],
-            description: "Explicit confirmation provider realization. Only mock is currently wired; user-mediated confirmation is not yet exposed.",
+            enum: ["mock", "direct_call"],
+            description: "Explicit confirmation provider realization. direct_call uses configured llm provider; mock is a test/fixture realization.",
         },
     },
 };
@@ -269,15 +366,25 @@ const TOOL_DEFINITIONS = [
         description: "Prepare an onto review session and prompt packets without executing lens units.",
         inputSchema: REVIEW_INPUT_SCHEMA,
     },
+    {
+        name: "onto.review_continue",
+        description: "Continue a review session when runControl.continuationAvailable is true by reusing trusted PipelineExecutionLedger units and rerunning only the continuation frontier and downstream units.",
+        inputSchema: REVIEW_CONTINUE_INPUT_SCHEMA,
+    },
+    {
+        name: "onto.review_cancel",
+        description: "Request cancellation for a running review session. The runner writes a halted cancellation result at the next runtime cancellation checkpoint.",
+        inputSchema: REVIEW_CANCEL_INPUT_SCHEMA,
+    },
     {
         name: "onto.review_status",
-        description: "Read structured status and artifact refs for a review session.",
-        inputSchema: SESSION_INPUT_SCHEMA,
+        description: "Read structured status and artifact refs for a review session, or recover the latest matching session.",
+        inputSchema: REVIEW_STATUS_INPUT_SCHEMA,
     },
     {
         name: "onto.review_result",
-        description: "Read the ReviewRecord and rendered final output for a completed review session.",
-        inputSchema: SESSION_INPUT_SCHEMA,
+        description: "Read the ReviewRecord and rendered final output for a completed review session with compact/standard/full projections.",
+        inputSchema: REVIEW_RESULT_INPUT_SCHEMA,
     },
     {
         name: "onto.list_lenses",
@@ -306,17 +413,17 @@ const TOOL_DEFINITIONS = [
     },
     {
         name: "onto.reconstruct",
-        description: "Run the material-aware reconstruct happy path with explicit mock semantic author and confirmation provider realization, returning final-output.md and reconstruct-record.yaml refs.",
+        description: "Run the material-aware reconstruct path with live semantic authoring, runtime validation gates, final-output.md, and reconstruct-record.yaml refs.",
         inputSchema: RECONSTRUCT_INPUT_SCHEMA,
     },
     {
         name: "onto.reconstruct_status",
-        description: "Read structured status and artifact refs for a reconstruct session.",
+        description: "Read structured status, stage progress, liveness, count summary, and artifact refs for a reconstruct session.",
         inputSchema: RECONSTRUCT_SESSION_INPUT_SCHEMA,
     },
     {
         name: "onto.reconstruct_result",
-        description: "Read the reconstruct record, run manifest, and final output for a reconstruct session.",
+        description: "Read the reconstruct record, run manifest, stage progress, final output, and artifact refs for a reconstruct session.",
         inputSchema: RECONSTRUCT_SESSION_INPUT_SCHEMA,
     },
 ];
@@ -371,6 +478,13 @@ function progressTokenFromToolCallParams(params) {
     const token = meta.progressToken;
     return typeof token === "string" || typeof token === "number" ? token : null;
 }
+function defaultReviewReturnRunningAfterMs() {
+    const raw = process.env.ONTO_MCP_REVIEW_RETURN_RUNNING_AFTER_MS;
+    if (raw === undefined || raw.trim().length === 0)
+        return 25_000;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 25_000;
+}
 function sendMcpProgressNotification(progressToken, event) {
     writeMessage({
         jsonrpc: "2.0",
@@ -409,6 +523,15 @@ function structuredFailureFromError(error) {
 }
 async function formatToolError(error) {
     const message = error instanceof Error ? error.message : String(error);
+    if (error instanceof ReviewContinuationError) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: message }],
+            structuredContent: {
+                continuationFailure: error.failureContent,
+            },
+        };
+    }
     const structuredFailure = structuredFailureFromError(error);
     const routeVisibility = structuredFailure
         ? await buildReviewRouteVisibilityFromFailure(structuredFailure.failure, structuredFailure.failureRecordPath)
@@ -429,18 +552,6 @@ async function formatToolError(error) {
             : {}),
     };
 }
-function isInsidePath(root, candidate) {
-    const relative = path.relative(path.resolve(root), path.resolve(candidate));
-    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
-}
-async function realpathIfExists(targetPath) {
-    try {
-        return await fs.realpath(targetPath);
-    }
-    catch {
-        return null;
-    }
-}
 function throwSessionDisclosureBlocked(args) {
     throw new ReviewStructuredFailureError({
         failureRecord: createStructuredFailureRecord({
@@ -500,7 +611,7 @@ async function resolveAllowedSessionRoot(args) {
     const resolvedSessionRoot = path.resolve(projectRoot, args.sessionRoot);
     const realProjectRoot = await realpathIfExists(projectRoot);
     const realAllowedRoot = await realpathIfExists(allowedRoot);
-    if (!isInsidePath(allowedRoot, resolvedSessionRoot)) {
+    if (!isPathInsideRoot(allowedRoot, resolvedSessionRoot)) {
         throwSessionDisclosureBlocked({
             requestedSessionRoot: args.sessionRoot,
             resolvedSessionRoot,
@@ -516,7 +627,7 @@ async function resolveAllowedSessionRoot(args) {
     const realSessionRoot = await realpathIfExists(resolvedSessionRoot);
     if (realSessionRoot &&
         realAllowedRoot &&
-        !isInsidePath(realAllowedRoot, realSessionRoot)) {
+        !isPathInsideRoot(realAllowedRoot, realSessionRoot)) {
         throwSessionDisclosureBlocked({
             requestedSessionRoot: args.sessionRoot,
             resolvedSessionRoot,
@@ -565,7 +676,7 @@ function resolveInsideProject(args) {
     const resolved = path.isAbsolute(args.ref)
         ? path.resolve(args.ref)
         : path.resolve(args.projectRoot, args.ref);
-    if (!isInsidePath(args.projectRoot, resolved)) {
+    if (!isPathInsideRoot(args.projectRoot, resolved)) {
         throw new Error(`${args.label} must stay inside projectRoot.`);
     }
     return resolved;
@@ -577,7 +688,7 @@ function resolveReconstructSessionRoot(args) {
     const resolved = path.isAbsolute(args.sessionRoot)
         ? path.resolve(args.sessionRoot)
         : path.resolve(args.projectRoot, args.sessionRoot);
-    if (!isInsidePath(allowedRoot, resolved)) {
+    if (!isPathInsideRoot(allowedRoot, resolved)) {
         throw new Error("sessionRoot must stay inside projectRoot/.onto/reconstruct.");
     }
     return resolved;
@@ -597,7 +708,7 @@ async function resolveAllowedReconstructSessionRoot(args) {
         : path.resolve(projectRoot, args.sessionRoot);
     const realProjectRoot = await realpathIfExists(projectRoot);
     const realAllowedRoot = await realpathIfExists(allowedRoot);
-    if (!isInsidePath(allowedRoot, resolvedSessionRoot)) {
+    if (!isPathInsideRoot(allowedRoot, resolvedSessionRoot)) {
         throwReconstructSessionDisclosureBlocked({
             requestedSessionRoot: args.sessionRoot,
             resolvedSessionRoot,
@@ -613,7 +724,7 @@ async function resolveAllowedReconstructSessionRoot(args) {
     const realSessionRoot = await realpathIfExists(resolvedSessionRoot);
     if (realSessionRoot &&
         realAllowedRoot &&
-        !isInsidePath(realAllowedRoot, realSessionRoot)) {
+        !isPathInsideRoot(realAllowedRoot, realSessionRoot)) {
         throwReconstructSessionDisclosureBlocked({
             requestedSessionRoot: args.sessionRoot,
             resolvedSessionRoot,
@@ -651,7 +762,7 @@ async function resolveAllowedReconstructSessionRoot(args) {
             if (typeof artifactRef !== "string" || artifactRef.length === 0)
                 continue;
             const resolvedArtifactRef = path.resolve(artifactRef);
-            if (!isInsidePath(resolvedSessionRoot, resolvedArtifactRef)) {
+            if (!isPathInsideRoot(resolvedSessionRoot, resolvedArtifactRef)) {
                 throwReconstructSessionDisclosureBlocked({
                     requestedSessionRoot: args.sessionRoot,
                     resolvedSessionRoot,
@@ -671,7 +782,7 @@ async function resolveAllowedReconstructSessionRoot(args) {
             const realArtifactRef = await realpathIfExists(resolvedArtifactRef);
             if (realArtifactRef &&
                 realSessionRoot &&
-                !isInsidePath(realSessionRoot, realArtifactRef)) {
+                !isPathInsideRoot(realSessionRoot, realArtifactRef)) {
                 throwReconstructSessionDisclosureBlocked({
                     requestedSessionRoot: args.sessionRoot,
                     resolvedSessionRoot,
@@ -706,6 +817,7 @@ async function callTool(name, args, options = {}) {
                 const progressToken = options.progressToken;
                 const result = await reviewApi.runReview({
                     ...request,
+                    returnRunningAfterMs: parsed.returnRunningAfterMs ?? defaultReviewReturnRunningAfterMs(),
                     ...(progressToken !== undefined && progressToken !== null
                         ? {
                             progressObserver: (event) => sendMcpProgressNotification(progressToken, event),
@@ -719,15 +831,87 @@ async function callTool(name, args, options = {}) {
                 const result = await reviewApi.prepareReview(toReviewRequest(parsed));
                 return formatToolResult(result);
             }
+            case "onto.review_continue": {
+                const parsed = OntoReviewContinueToolInputSchema.parse(args);
+                const projectRoot = resolveProjectRoot(parsed.projectRoot);
+                const sessionRoot = await resolveAllowedSessionRoot({
+                    sessionRoot: parsed.sessionRoot,
+                    projectRoot,
+                });
+                const result = await reviewApi.continueReview({
+                    projectRoot,
+                    sessionRoot,
+                    ...(parsed.targetUnits !== undefined
+                        ? { targetUnits: parsed.targetUnits }
+                        : {}),
+                    ...(parsed.requestText !== undefined
+                        ? { requestText: parsed.requestText }
+                        : {}),
+                    ...(parsed.executorRealization !== undefined
+                        ? { executorRealization: parsed.executorRealization }
+                        : {}),
+                });
+                return formatToolResult(result);
+            }
+            case "onto.review_cancel": {
+                const parsed = OntoReviewCancelToolInputSchema.parse(args);
+                const projectRoot = resolveProjectRoot(parsed.projectRoot);
+                const sessionRoot = await resolveAllowedSessionRoot({
+                    sessionRoot: parsed.sessionRoot,
+                    projectRoot,
+                });
+                return formatToolResult(await reviewApi.cancelReview({
+                    projectRoot,
+                    sessionRoot,
+                    ...(parsed.reason !== undefined ? { reason: parsed.reason } : {}),
+                }));
+            }
             case "onto.review_status": {
-                const parsed = OntoReviewSessionInputSchema.parse(args);
-                const sessionRoot = await resolveAllowedSessionRoot(parsed);
-                return formatToolResult(await reviewApi.getReviewStatus(sessionRoot));
+                const parsed = OntoReviewStatusInputSchema.parse(args);
+                const projectRoot = resolveProjectRoot(parsed.projectRoot);
+                if (parsed.sessionRoot) {
+                    const sessionRoot = await resolveAllowedSessionRoot({
+                        sessionRoot: parsed.sessionRoot,
+                        projectRoot,
+                    });
+                    return formatToolResult(await reviewApi.getReviewStatus(sessionRoot));
+                }
+                const latestSessionMatches = await reviewApi.findLatestReviewSessions({
+                    projectRoot,
+                    ...(parsed.target !== undefined ? { target: parsed.target } : {}),
+                    ...(parsed.domain !== undefined ? { domain: parsed.domain } : {}),
+                    ...(parsed.requestHash !== undefined
+                        ? { requestHash: parsed.requestHash }
+                        : {}),
+                    ...(parsed.limit !== undefined ? { limit: parsed.limit } : {}),
+                });
+                const latest = latestSessionMatches[0];
+                if (!latest) {
+                    return formatToolResult({
+                        sessionId: null,
+                        sessionRoot: null,
+                        status: "unknown",
+                        artifactRefs: {},
+                        failureRefs: [],
+                        structuredFailures: [],
+                        latestSessionMatches,
+                    });
+                }
+                const sessionRoot = await resolveAllowedSessionRoot({
+                    sessionRoot: latest.sessionRoot,
+                    projectRoot,
+                });
+                return formatToolResult({
+                    ...(await reviewApi.getReviewStatus(sessionRoot)),
+                    latestSessionMatches,
+                });
             }
             case "onto.review_result": {
-                const parsed = OntoReviewSessionInputSchema.parse(args);
+                const parsed = OntoReviewResultInputSchema.parse(args);
                 const sessionRoot = await resolveAllowedSessionRoot(parsed);
-                return formatToolResult(await reviewApi.getReviewResult(sessionRoot));
+                return formatToolResult(await reviewApi.getReviewResult(sessionRoot, {
+                    projectionLevel: parsed.projectionLevel ?? "standard",
+                }));
             }
             case "onto.list_lenses":
                 return formatToolResult(await reviewApi.listLenses());
@@ -931,9 +1115,62 @@ async function handleRequest(message) {
             return jsonRpcError(message.id, -32601, `Method not found: ${message.method ?? "(missing)"}`);
     }
 }
-function writeMessage(message) {
+let stdioResponseFraming = "jsonl";
+function writeMessage(message, framing = stdioResponseFraming) {
     const body = JSON.stringify(message);
-    process.stdout.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`);
+    if (framing === "content-length") {
+        process.stdout.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`);
+        return;
+    }
+    process.stdout.write(`${body}\n`);
+}
+function lineEndIndex(buffer) {
+    const lf = buffer.indexOf("\n");
+    if (lf < 0)
+        return null;
+    const crlf = lf > 0 && buffer[lf - 1] === 13;
+    return { index: crlf ? lf - 1 : lf, length: crlf ? 2 : 1 };
+}
+function shouldReadContentLengthFrame(buffer) {
+    const firstLineEnd = lineEndIndex(buffer);
+    const firstLine = buffer
+        .subarray(0, firstLineEnd?.index ?? buffer.length)
+        .toString("utf8");
+    return /^Content-Length:/i.test(firstLine);
+}
+function readNextStdioMessage(buffer) {
+    if (buffer.length === 0)
+        return null;
+    if (!shouldReadContentLengthFrame(buffer)) {
+        const lineEnd = lineEndIndex(buffer);
+        if (!lineEnd)
+            return null;
+        const body = buffer.subarray(0, lineEnd.index).toString("utf8");
+        return {
+            body,
+            framing: "jsonl",
+            rest: buffer.subarray(lineEnd.index + lineEnd.length),
+        };
+    }
+    const headerEnd = headerEndIndex(buffer);
+    if (!headerEnd)
+        return null;
+    const header = buffer.subarray(0, headerEnd.index).toString("utf8");
+    const contentLength = parseContentLength(header);
+    const totalLength = headerEnd.index + headerEnd.length + contentLength;
+    if (buffer.length < totalLength)
+        return null;
+    const body = buffer
+        .subarray(headerEnd.index + headerEnd.length, totalLength)
+        .toString("utf8");
+    return {
+        body,
+        framing: "content-length",
+        rest: buffer.subarray(totalLength),
+    };
+}
+function writeParseError(error, framing) {
+    writeMessage(jsonRpcError(null, -32700, error instanceof Error ? error.message : String(error)), framing);
 }
 function headerEndIndex(buffer) {
     const crlf = buffer.indexOf("\r\n\r\n");
@@ -957,38 +1194,31 @@ export async function startMcpServer() {
     process.stdin.on("data", (chunk) => {
         buffer = Buffer.concat([buffer, chunk]);
         while (true) {
-            const headerEnd = headerEndIndex(buffer);
-            if (!headerEnd)
-                return;
-            const header = buffer.subarray(0, headerEnd.index).toString("utf8");
-            let contentLength;
+            let frame;
             try {
-                contentLength = parseContentLength(header);
+                frame = readNextStdioMessage(buffer);
             }
             catch (error) {
-                writeMessage(jsonRpcError(null, -32700, error instanceof Error ? error.message : String(error)));
+                writeParseError(error, stdioResponseFraming);
                 buffer = Buffer.alloc(0);
                 return;
             }
-            const totalLength = headerEnd.index + headerEnd.length + contentLength;
-            if (buffer.length < totalLength)
+            if (!frame)
                 return;
-            const body = buffer
-                .subarray(headerEnd.index + headerEnd.length, totalLength)
-                .toString("utf8");
-            buffer = buffer.subarray(totalLength);
+            buffer = frame.rest;
+            stdioResponseFraming = frame.framing;
             chain = chain.then(async () => {
                 let request;
                 try {
-                    request = JSON.parse(body);
+                    request = JSON.parse(frame.body);
                 }
                 catch (error) {
-                    writeMessage(jsonRpcError(null, -32700, error instanceof Error ? error.message : String(error)));
+                    writeMessage(jsonRpcError(null, -32700, error instanceof Error ? error.message : String(error)), frame.framing);
                     return;
                 }
                 const response = await handleRequest(request);
                 if (response)
-                    writeMessage(response);
+                    writeMessage(response, frame.framing);
             }).catch((error) => {
                 process.stderr.write(`[onto-mcp] request failed: ${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
             });

package/dist/mcp/tool-schemas.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 const ReviewModeSchema = z.enum(["core-axis", "full"]);
 const ReviewTargetScopeKindSchema = z.enum(["file", "directory", "bundle"]);
 const ExecutorRealizationSchema = z.enum(["codex", "mock", "ts_inline_http"]);
+const ReviewResultProjectionLevelSchema = z.enum(["compact", "standard", "full"]);
 const DeliberationModeSchema = z.enum([
     "controlled_lens_deliberation",
 ]);
@@ -22,6 +23,7 @@ const OntoReviewToolInputBaseSchema = z.object({
     executorRealization: ExecutorRealizationSchema.optional(),
     confirmValueAlignment: z.boolean().optional(),
     prepareOnly: z.boolean().optional(),
+    returnRunningAfterMs: z.number().int().min(0).optional(),
 }).strict();
 export const OntoReviewToolInputSchema = OntoReviewToolInputBaseSchema.refine((input) => !(input.domain && input.noDomain), {
     message: "Use either domain or noDomain, not both.",
@@ -35,6 +37,28 @@ export const OntoReviewSessionInputSchema = z.object({
     sessionRoot: z.string().min(1),
     projectRoot: z.string().min(1).optional(),
 });
+export const OntoReviewStatusInputSchema = z.object({
+    sessionRoot: z.string().min(1).optional(),
+    projectRoot: z.string().min(1).optional(),
+    latest: z.boolean().optional(),
+    target: z.string().min(1).optional(),
+    domain: z.string().min(1).optional(),
+    requestHash: z.string().min(1).optional(),
+    limit: z.number().int().min(1).max(20).optional(),
+}).strict().refine((input) => (typeof input.sessionRoot === "string" || input.latest === true), {
+    message: "Pass sessionRoot, or latest=true with optional target/domain/requestHash filters.",
+});
+export const OntoReviewResultInputSchema = OntoReviewSessionInputSchema.extend({
+    projectionLevel: ReviewResultProjectionLevelSchema.optional(),
+}).strict();
+export const OntoReviewCancelToolInputSchema = OntoReviewSessionInputSchema.extend({
+    reason: z.string().min(1).optional(),
+}).strict();
+export const OntoReviewContinueToolInputSchema = OntoReviewSessionInputSchema.extend({
+    targetUnits: z.array(z.string().min(1)).optional(),
+    requestText: z.string().min(1).optional(),
+    executorRealization: ExecutorRealizationSchema.optional(),
+}).strict();
 export const OntoListDomainsToolInputSchema = z.object({
     projectRoot: z.string().min(1).optional(),
 });
@@ -50,8 +74,8 @@ export const OntoObserveSourceToolInputSchema = z.object({
 }).strict();
 export const OntoReconstructToolInputSchema = OntoObserveSourceToolInputSchema.extend({
     intent: z.string().min(1),
-    semanticAuthorRealization: z.literal("mock"),
-    confirmationProviderRealization: z.literal("mock"),
+    semanticAuthorRealization: z.enum(["mock", "direct_call"]).default("direct_call"),
+    confirmationProviderRealization: z.enum(["mock", "direct_call"]).default("direct_call"),
 }).strict();
 export const OntoReconstructSessionInputSchema = z.object({
     sessionRoot: z.string().min(1),
@@ -80,6 +104,8 @@ export const OntoValidateReconstructDirectiveToolInputSchema = z.discriminatedUn
 export const OntoToolNames = [
     "onto.review",
     "onto.prepare_review",
+    "onto.review_continue",
+    "onto.review_cancel",
     "onto.review_status",
     "onto.review_result",
     "onto.list_lenses",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onto-mcp",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "MCP-native ontology review runtime with context-isolated lenses and controlled deliberation",
   "homepage": "https://github.com/kangminlee-maker/onto-mcp#readme",
   "bugs": {
@@ -32,6 +32,7 @@
     "prepare": "npm run build:ts-core",
     "build:ts-core": "tsc -p tsconfig.json",
     "check:ts-core": "tsc -p tsconfig.json --noEmit",
+    "test:review:invocation-runner": "tsx scripts/review-invocation-runner-conformance.ts",
     "test:mcp:review": "tsx scripts/mcp-review-conformance.ts",
     "test:review:hardening": "tsx scripts/review-runtime-hardening.ts",
     "test:e2e": "bash src/core-runtime/cli/e2e-review-invoke.test.sh",
@@ -44,6 +45,7 @@
     "review:codex-unit-executor": "tsx src/core-runtime/cli/codex-review-unit-executor.ts",
     "review:inline-http-unit-executor": "tsx src/core-runtime/cli/inline-http-review-unit-executor.ts",
     "review:invoke": "tsx src/core-runtime/cli/review-invoke.ts",
+    "review:watch": "bash scripts/onto-review-watch.sh",
     "mcp:server": "tsx src/mcp/server.ts",
     "review:render-final-output": "tsx src/core-runtime/cli/render-review-final-output.ts",
     "review:finalize-session": "tsx src/core-runtime/cli/assemble-review-record.ts",
@@ -51,7 +53,7 @@
     "review:assemble-record": "tsx src/core-runtime/cli/assemble-review-record.ts"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.82.0",
+    "@anthropic-ai/sdk": "^0.99.0",
     "openai": "^6.33.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.6"