onto-mcp 0.3.2 → 0.4.0

package/dist/core-runtime/review/review-invocation-runner.js

@@ -422,9 +422,9 @@ export async function runReviewInvocationArgv(argv, observer) {
 async function projectLegacyReviewInvocationOutput(args) {
     const reviewSummary = await readOptionalReviewSummary(args.sessionRoot);
     const boundedInvokeSteps = [
-        "review:start-session",
-        "review:run-prompt-execution",
-        "review:complete-session",
+        "start_review_session",
+        "run_review_prompt_execution",
+        "complete_review_session",
     ];
     const effectiveReviewExecutionProfile = args.setup.executionProfile.review_execution_profile;
     const finalRoute = buildReviewExecutionRoute(effectiveReviewExecutionProfile);
@@ -435,7 +435,7 @@ async function projectLegacyReviewInvocationOutput(args) {
         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/mcp/server.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { createOntoReviewCoreApi, ReviewContinuationError, } from "../core-api/review-api.js";
 import { createOntoReconstructCoreApi, } from "../core-api/reconstruct-api.js";
+import { RECONSTRUCT_DOMAIN_ID_GRAMMAR_DESCRIPTION, RECONSTRUCT_DOMAIN_ID_PATTERN, } from "../core-runtime/reconstruct/domain-id.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";
@@ -288,6 +289,16 @@ const RECONSTRUCT_INPUT_SCHEMA = {
             type: "string",
             description: "Declared reconstruction purpose. The runner passes this to the directive author and does not infer ontology meaning itself.",
         },
+        domain: {
+            type: "string",
+            pattern: RECONSTRUCT_DOMAIN_ID_PATTERN.source,
+            description: `Optional domain id whose competency_qs.md is admitted into the reconstruct run governing snapshot. Must use ${RECONSTRUCT_DOMAIN_ID_GRAMMAR_DESCRIPTION}.`,
+        },
+        resumeMode: {
+            type: "string",
+            enum: ["fresh", "reuse_existing_authored_artifacts"],
+            description: "Optional explicit same-session resume mode. fresh fails before rewriting authored semantic artifacts; reuse_existing_authored_artifacts reuses existing authored YAML artifacts and reruns downstream runtime validation gates.",
+        },
         semanticAuthorRealization: {
             type: "string",
             enum: ["mock", "direct_call"],
@@ -319,11 +330,42 @@ const VALIDATE_RECONSTRUCT_DIRECTIVE_INPUT_SCHEMA = {
     type: "object",
     additionalProperties: false,
     required: ["directiveKind", "sourceObservationsPath"],
+    allOf: [
+        {
+            if: {
+                properties: { directiveKind: { const: "source_observation" } },
+                required: ["directiveKind"],
+            },
+            then: { required: ["directivePath"] },
+        },
+        {
+            if: {
+                properties: { directiveKind: { const: "candidate_disposition" } },
+                required: ["directiveKind"],
+            },
+            then: {
+                required: ["candidateInventoryPath", "candidateDispositionPath"],
+            },
+        },
+        {
+            if: {
+                properties: { directiveKind: { const: "ontology_seed" } },
+                required: ["directiveKind"],
+            },
+            then: {
+                required: ["ontologySeedPath", "candidateDispositionPath"],
+            },
+        },
+    ],
     properties: {
         directiveKind: {
             type: "string",
-            enum: ["source_observation", "seed_candidate"],
-            description: "Which LLM-authored reconstruct directive shape to validate.",
+            enum: [
+                "source_observation",
+                "candidate_disposition",
+                "ontology_seed",
+            ],
+            description: "Which LLM-authored reconstruct artifact shape to validate.",
         },
         projectRoot: {
             type: "string",
@@ -333,21 +375,25 @@ const VALIDATE_RECONSTRUCT_DIRECTIVE_INPUT_SCHEMA = {
             type: "string",
             description: "Path to source-observation-directive.yaml when directiveKind=source_observation.",
         },
-        seedCandidatePath: {
+        candidateInventoryPath: {
             type: "string",
-            description: "Path to seed-candidate.yaml when directiveKind=seed_candidate.",
+            description: "Path to candidate-inventory.yaml when directiveKind=candidate_disposition.",
         },
-        sourceObservationsPath: {
+        candidateDispositionPath: {
             type: "string",
-            description: "Path to source-observations.yaml.",
+            description: "Path to candidate-disposition.yaml when directiveKind=candidate_disposition or ontology_seed.",
         },
-        sourceObservationDirectivePath: {
+        ontologySeedPath: {
             type: "string",
-            description: "Optional path to source-observation-directive.yaml for Seed validation.",
+            description: "Path to ontology-seed.yaml when directiveKind=ontology_seed.",
         },
-        sourceObservationDirectiveValidationPath: {
+        sourceObservationsPath: {
             type: "string",
-            description: "Optional path to source-observation-directive-validation.yaml for Seed validation.",
+            description: "Path to source-observations.yaml.",
+        },
+        registryPath: {
+            type: "string",
+            description: "Optional path to reconstruct-contract-registry.yaml for registry-backed validators.",
         },
         outputPath: {
             type: "string",
@@ -408,7 +454,7 @@ const TOOL_DEFINITIONS = [
     },
     {
         name: "onto.validate_reconstruct_directive",
-        description: "Validate LLM-authored reconstruct directive files against runtime observations and evidence refs without repairing or rewriting them.",
+        description: "Validate LLM-authored reconstruct artifacts against runtime observations, registry enums, and evidence refs without repairing or rewriting them.",
         inputSchema: VALIDATE_RECONSTRUCT_DIRECTIVE_INPUT_SCHEMA,
     },
     {
@@ -981,33 +1027,57 @@ async function callTool(name, args, options = {}) {
                         ...(outputPath ? { outputPath } : {}),
                     }));
                 }
-                return formatToolResult(await reconstructApi.validateSeedCandidate({
-                    seedCandidatePath: resolveInsideProject({
-                        projectRoot,
-                        ref: parsed.seedCandidatePath,
-                        label: "seedCandidatePath",
-                    }),
-                    sourceObservationsPath,
-                    ...(parsed.sourceObservationDirectivePath
-                        ? {
-                            sourceObservationDirectivePath: resolveInsideProject({
-                                projectRoot,
-                                ref: parsed.sourceObservationDirectivePath,
-                                label: "sourceObservationDirectivePath",
-                            }),
-                        }
-                        : {}),
-                    ...(parsed.sourceObservationDirectiveValidationPath
-                        ? {
-                            sourceObservationDirectiveValidationPath: resolveInsideProject({
-                                projectRoot,
-                                ref: parsed.sourceObservationDirectiveValidationPath,
-                                label: "sourceObservationDirectiveValidationPath",
-                            }),
-                        }
-                        : {}),
-                    ...(outputPath ? { outputPath } : {}),
-                }));
+                if (parsed.directiveKind === "candidate_disposition") {
+                    return formatToolResult(await reconstructApi.validateCandidateDisposition({
+                        candidateInventoryPath: resolveInsideProject({
+                            projectRoot,
+                            ref: parsed.candidateInventoryPath,
+                            label: "candidateInventoryPath",
+                        }),
+                        candidateDispositionPath: resolveInsideProject({
+                            projectRoot,
+                            ref: parsed.candidateDispositionPath,
+                            label: "candidateDispositionPath",
+                        }),
+                        sourceObservationsPath,
+                        ...(parsed.registryPath
+                            ? {
+                                registryPath: resolveInsideProject({
+                                    projectRoot,
+                                    ref: parsed.registryPath,
+                                    label: "registryPath",
+                                }),
+                            }
+                            : {}),
+                        ...(outputPath ? { outputPath } : {}),
+                    }));
+                }
+                if (parsed.directiveKind === "ontology_seed") {
+                    return formatToolResult(await reconstructApi.validateActionableOntologySeed({
+                        ontologySeedPath: resolveInsideProject({
+                            projectRoot,
+                            ref: parsed.ontologySeedPath,
+                            label: "ontologySeedPath",
+                        }),
+                        candidateDispositionPath: resolveInsideProject({
+                            projectRoot,
+                            ref: parsed.candidateDispositionPath,
+                            label: "candidateDispositionPath",
+                        }),
+                        sourceObservationsPath,
+                        ...(parsed.registryPath
+                            ? {
+                                registryPath: resolveInsideProject({
+                                    projectRoot,
+                                    ref: parsed.registryPath,
+                                    label: "registryPath",
+                                }),
+                            }
+                            : {}),
+                        ...(outputPath ? { outputPath } : {}),
+                    }));
+                }
+                throw new Error("Unsupported reconstruct directive kind.");
             }
             case "onto.reconstruct": {
                 const parsed = OntoReconstructToolInputSchema.parse(args);
@@ -1037,6 +1107,8 @@ async function callTool(name, args, options = {}) {
                     projectRoot,
                     targetRefs,
                     intent: parsed.intent,
+                    ...(parsed.domain !== undefined ? { domain: parsed.domain } : {}),
+                    ...(parsed.resumeMode !== undefined ? { resumeMode: parsed.resumeMode } : {}),
                     semanticAuthorRealization: parsed.semanticAuthorRealization,
                     confirmationProviderRealization: parsed.confirmationProviderRealization,
                     ...(sessionRoot ? { sessionRoot } : {}),

package/dist/mcp/tool-schemas.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { RECONSTRUCT_DOMAIN_ID_GRAMMAR_DESCRIPTION, RECONSTRUCT_DOMAIN_ID_PATTERN, } from "../core-runtime/reconstruct/domain-id.js";
 const ReviewModeSchema = z.enum(["core-axis", "full"]);
 const ReviewTargetScopeKindSchema = z.enum(["file", "directory", "bundle"]);
 const ExecutorRealizationSchema = z.enum(["codex", "mock", "ts_inline_http"]);
@@ -6,6 +7,7 @@ const ReviewResultProjectionLevelSchema = z.enum(["compact", "standard", "full"]
 const DeliberationModeSchema = z.enum([
     "controlled_lens_deliberation",
 ]);
+const ReconstructDomainIdSchema = z.string().regex(RECONSTRUCT_DOMAIN_ID_PATTERN, `domain must use ${RECONSTRUCT_DOMAIN_ID_GRAMMAR_DESCRIPTION}`);
 const OntoReviewToolInputBaseSchema = z.object({
     target: z.string().min(1),
     intent: z.string().min(1),
@@ -74,6 +76,8 @@ export const OntoObserveSourceToolInputSchema = z.object({
 }).strict();
 export const OntoReconstructToolInputSchema = OntoObserveSourceToolInputSchema.extend({
     intent: z.string().min(1),
+    domain: ReconstructDomainIdSchema.optional(),
+    resumeMode: z.enum(["fresh", "reuse_existing_authored_artifacts"]).optional(),
     semanticAuthorRealization: z.enum(["mock", "direct_call"]).default("direct_call"),
     confirmationProviderRealization: z.enum(["mock", "direct_call"]).default("direct_call"),
 }).strict();
@@ -88,18 +92,28 @@ const OntoValidateSourceObservationDirectiveToolInputSchema = z.object({
     outputPath: z.string().min(1).optional(),
     projectRoot: z.string().min(1).optional(),
 }).strict();
-const OntoValidateSeedCandidateToolInputSchema = z.object({
-    directiveKind: z.literal("seed_candidate"),
-    seedCandidatePath: z.string().min(1),
+const OntoValidateCandidateDispositionToolInputSchema = z.object({
+    directiveKind: z.literal("candidate_disposition"),
+    candidateInventoryPath: z.string().min(1),
+    candidateDispositionPath: z.string().min(1),
     sourceObservationsPath: z.string().min(1),
-    sourceObservationDirectivePath: z.string().min(1).optional(),
-    sourceObservationDirectiveValidationPath: z.string().min(1).optional(),
+    registryPath: z.string().min(1).optional(),
+    outputPath: z.string().min(1).optional(),
+    projectRoot: z.string().min(1).optional(),
+}).strict();
+const OntoValidateOntologySeedToolInputSchema = z.object({
+    directiveKind: z.literal("ontology_seed"),
+    ontologySeedPath: z.string().min(1),
+    candidateDispositionPath: z.string().min(1),
+    sourceObservationsPath: z.string().min(1),
+    registryPath: z.string().min(1).optional(),
     outputPath: z.string().min(1).optional(),
     projectRoot: z.string().min(1).optional(),
 }).strict();
 export const OntoValidateReconstructDirectiveToolInputSchema = z.discriminatedUnion("directiveKind", [
     OntoValidateSourceObservationDirectiveToolInputSchema,
-    OntoValidateSeedCandidateToolInputSchema,
+    OntoValidateCandidateDispositionToolInputSchema,
+    OntoValidateOntologySeedToolInputSchema,
 ]);
 export const OntoToolNames = [
     "onto.review",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onto-mcp",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "MCP-native ontology review runtime with context-isolated lenses and controlled deliberation",
   "homepage": "https://github.com/kangminlee-maker/onto-mcp#readme",
   "bugs": {
@@ -19,6 +19,9 @@
   "files": [
     "bin/",
     "dist/",
+    "scripts/onto-runtime-watch.sh",
+    "scripts/onto-review-watch.sh",
+    "scripts/postinstall-hint.js",
     ".onto/roles/",
     ".onto/domains/",
     ".onto/authority/",
@@ -30,27 +33,15 @@
   ],
   "scripts": {
     "prepare": "npm run build:ts-core",
-    "build:ts-core": "tsc -p tsconfig.json",
+    "postinstall": "node scripts/postinstall-hint.js",
+    "clean:ts-core": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build:ts-core": "npm run clean: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",
-    "test:e2e:codex-multi-agent-fixes": "vitest run src/core-runtime/cli/e2e-codex-multi-agent-fixes.test.ts",
-    "review:prepare-session": "tsx src/core-runtime/cli/prepare-review-session.ts",
-    "review:materialize-prompt-packets": "tsx src/core-runtime/cli/materialize-review-prompt-packets.ts",
-    "review:start-session": "tsx src/core-runtime/cli/start-review-session.ts",
-    "review:run-prompt-execution": "tsx src/core-runtime/cli/run-review-prompt-execution.ts",
-    "review:mock-unit-executor": "tsx src/core-runtime/cli/mock-review-unit-executor.ts",
-    "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",
-    "review:complete-session": "tsx src/core-runtime/cli/complete-review-session.ts",
-    "review:assemble-record": "tsx src/core-runtime/cli/assemble-review-record.ts"
+    "test:e2e:codex-multi-agent-fixes": "vitest run src/core-runtime/cli/e2e-codex-multi-agent-fixes.test.ts"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.99.0",