@smartergpt/lexrunner 1.0.0 → 1.3.0

package/mcp-server.mjs

@@ -44,8 +44,218 @@ try {
   process.exit(1);
 }
 
+const attemptLifecycleHandlers = core.createAttemptLifecycleHandlers();
+const containmentPreflightHandler = core.createAgentWorkContainmentPreflightHandler();
+const projectionLifecycleHandlers = core.createNativeWslProjectionLifecycleHandlers();
+const attemptWorkerHandlers = core.createAttemptWorkerHandlers();
+const attemptReceiptHandlers = core.createAttemptReceiptHandlers();
+const attemptVerificationHandlers = core.createAttemptVerificationHandlers();
+
+function sharedServiceError(error, tool, fallbackCode) {
+  if (error && typeof error === "object" && typeof error.code === "string") {
+    const planArtifactContext =
+      error.name === "PlanArtifactServiceError"
+        ? {
+            operation: "resolve plan artifact",
+            details: error.source ? { source: error.source } : undefined,
+          }
+        : {};
+    return new Error(
+      core.canonicalJSONStringify(
+        core.mcpToolError(error.code, error.message || "Shared service failed", {
+          tool,
+          ...planArtifactContext,
+        })
+      )
+    );
+  }
+  return new Error(
+    core.canonicalJSONStringify(
+      core.mcpToolError(fallbackCode, error instanceof Error ? error.message : String(error), {
+        tool,
+      })
+    )
+  );
+}
+
 // MCP Tool implementations
 const tools = {
+  preflight_attempt_containment: {
+    description:
+      "Read physical-containment capability before constructing an agent-work Attempt packet",
+    inputSchema: core.AgentWorkContainmentPreflightRequestJsonSchema,
+    call: async (args) => canonicalToolResult(await containmentPreflightHandler.preflight(args)),
+  },
+
+  prepare_native_wsl_projection: {
+    description: "Prepare or exactly reuse an identity-anchored native WSL projection",
+    inputSchema: core.NativeWslProjectionPrepareRequestJsonSchema,
+    call: async (args) =>
+      mutationToolCall("prepare a native WSL projection", () =>
+        projectionLifecycleHandlers.prepare(args)
+      ),
+  },
+
+  get_native_wsl_projection_status: {
+    description: "Read bounded native WSL projection status without creating state",
+    inputSchema: core.NativeWslProjectionStatusRequestJsonSchema,
+    call: async (args) => canonicalToolResult(await projectionLifecycleHandlers.status(args)),
+  },
+
+  cleanup_native_wsl_projection: {
+    description: "Remove exact idle native WSL projection and quarantine state",
+    inputSchema: core.NativeWslProjectionCleanupRequestJsonSchema,
+    call: async (args) =>
+      mutationToolCall("clean up a native WSL projection", () =>
+        projectionLifecycleHandlers.cleanup(args)
+      ),
+  },
+
+  inspect_native_wsl_projection_quarantine: {
+    description: "Inspect privacy-bounded native WSL projection quarantine state",
+    inputSchema: core.NativeWslProjectionQuarantineRequestJsonSchema,
+    call: async (args) => canonicalToolResult(await projectionLifecycleHandlers.quarantine(args)),
+  },
+
+  verify_attempt: {
+    description: "Run packet-declared engine verification for one fenced Attempt",
+    inputSchema: core.AttemptVerificationRunRequestJsonSchema,
+    call: async (args) =>
+      mutationToolCall("verify an Attempt", () => attemptVerificationHandlers.run(args)),
+  },
+
+  get_attempt_verification: {
+    description: "Get compact verification status, with explicit optional diagnostics",
+    inputSchema: core.AttemptVerificationStatusRequestJsonSchema,
+    call: async (args) => canonicalToolResult(await attemptVerificationHandlers.status(args)),
+  },
+
+  accept_attempt: {
+    description: "Apply LexRunner's strict acceptance policy to verified evidence",
+    inputSchema: core.AttemptAcceptanceApplyRequestJsonSchema,
+    call: async (args) =>
+      mutationToolCall("accept an Attempt", () =>
+        attemptVerificationHandlers.applyAcceptance(args)
+      ),
+  },
+
+  get_attempt_acceptance: {
+    description: "Get bounded policy-acceptance status for one Attempt",
+    inputSchema: core.AttemptAcceptanceStatusRequestJsonSchema,
+    call: async (args) =>
+      canonicalToolResult(await attemptVerificationHandlers.acceptanceStatus(args)),
+  },
+
+  submit_attempt_receipt: {
+    description: "Persist one bounded AgentTaskReceipt v2 claim for an Attempt",
+    inputSchema: core.AttemptReceiptSubmitRequestJsonSchema,
+    call: async (args) =>
+      mutationToolCall("submit an Attempt receipt", () => attemptReceiptHandlers.submit(args)),
+  },
+
+  get_attempt_receipt: {
+    description: "Get bounded, read-only status for one persisted Attempt receipt",
+    inputSchema: core.AttemptReceiptStatusRequestJsonSchema,
+    call: async (args) => canonicalToolResult(await attemptReceiptHandlers.status(args)),
+  },
+
+  attach_attempt_worker: {
+    description: "Attach a native worker session to an authorized Attempt",
+    inputSchema: core.AttemptWorkerAttachRequestJsonSchema,
+    call: async (args) =>
+      mutationToolCall("attach an Attempt worker", () => attemptWorkerHandlers.attach(args)),
+  },
+
+  heartbeat_attempt_worker: {
+    description: "Record a fenced heartbeat for an attached Attempt worker",
+    inputSchema: core.AttemptWorkerHeartbeatRequestJsonSchema,
+    call: async (args) =>
+      mutationToolCall("heartbeat an Attempt worker", () => attemptWorkerHandlers.heartbeat(args)),
+  },
+
+  end_attempt_worker: {
+    description: "End an attached Attempt worker session",
+    inputSchema: core.AttemptWorkerEndRequestJsonSchema,
+    call: async (args) =>
+      mutationToolCall("end an Attempt worker", () => attemptWorkerHandlers.end(args)),
+  },
+
+  get_attempt_worker: {
+    description: "Get bounded, read-only status for an attached Attempt worker",
+    inputSchema: core.AttemptWorkerStatusRequestJsonSchema,
+    call: async (args) => {
+      const result = await attemptWorkerHandlers.status(args);
+      return canonicalToolResult(result);
+    },
+  },
+
+  prepare_attempt: {
+    description:
+      "Prepare an ADR-010 assisted launch packet and envelope (requires ALLOW_MUTATIONS=true)",
+    inputSchema: core.AttemptPrepareRequestJsonSchema,
+    call: async (args) => {
+      if (!config.allowMutations) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: core.canonicalJSONStringify({
+                ok: false,
+                error: {
+                  code: "mutations_disabled",
+                  message: "Mutations not allowed. Set ALLOW_MUTATIONS=true to prepare an Attempt.",
+                },
+              }),
+            },
+          ],
+        };
+      }
+      const result = await attemptLifecycleHandlers.prepare(args);
+      return {
+        content: [{ type: "text", text: core.canonicalJSONStringify(result) }],
+      };
+    },
+  },
+
+  start_attempt: {
+    description:
+      "Start or safely resume an ADR-010 agent-work Attempt (requires ALLOW_MUTATIONS=true)",
+    inputSchema: core.AttemptStartRequestJsonSchema,
+    call: async (args) => {
+      if (!config.allowMutations) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: core.canonicalJSONStringify({
+                ok: false,
+                error: {
+                  code: "mutations_disabled",
+                  message: "Mutations not allowed. Set ALLOW_MUTATIONS=true to start an Attempt.",
+                },
+              }),
+            },
+          ],
+        };
+      }
+      const result = await attemptLifecycleHandlers.start(args);
+      return {
+        content: [{ type: "text", text: core.canonicalJSONStringify(result) }],
+      };
+    },
+  },
+
+  get_attempt_status: {
+    description: "Get bounded, read-only status for an ADR-010 agent-work Attempt",
+    inputSchema: core.AttemptStatusInputJsonSchema,
+    call: async (args) => {
+      const result = await attemptLifecycleHandlers.status(args);
+      return {
+        content: [{ type: "text", text: core.canonicalJSONStringify(result) }],
+      };
+    },
+  },
+
   "plan.create": {
     description: "Create a plan from configuration files or auto-discover from GitHub PRs",
     inputSchema: {
@@ -137,7 +347,7 @@ const tools = {
 
         if (args.fromGithub) {
           // GitHub mode: auto-discover PRs
-          const { createGitHubClient, generatePlanFromGitHub } = await import("./dist/cli.js");
+          const { createGitHubClient, PlanCreationService } = await import("./dist/cli.js");
 
           const client = await createGitHubClient({
             token: args.githubToken,
@@ -152,7 +362,7 @@ const tools = {
           const maxWorkers = args.maxWorkers || 2;
 
           // Generate plan from GitHub
-          plan = await generatePlanFromGitHub(client, {
+          plan = await new PlanCreationService().fromGitHub(client, {
             query: args.query,
             labels: args.labels,
             excludePRs: args.excludePRs,
@@ -165,9 +375,9 @@ const tools = {
           });
         } else {
           // Traditional mode: load from configuration files
-          const { loadInputs, generatePlan } = await import("./dist/cli.js");
+          const { loadInputs, PlanCreationService } = await import("./dist/cli.js");
           inputs = loadInputs(profilePath);
-          plan = generatePlan(inputs);
+          plan = new PlanCreationService().fromInputs(inputs);
         }
 
         // Determine output directory
@@ -200,6 +410,7 @@ const tools = {
         writeFileSync(snapshotPath, snapshot);
 
         const result = {
+          contract: "bounded-ax-v1",
           plan: plan,
           outDir: outDir,
           files: {
@@ -212,7 +423,7 @@ const tools = {
           content: [
             {
               type: "text",
-              text: `Plan created successfully:\n${JSON.stringify(result, null, 2)}`,
+              text: JSON.stringify(result, null, 2),
             },
           ],
         };
@@ -227,6 +438,11 @@ const tools = {
     inputSchema: {
       type: "object",
       properties: {
+        planFile: {
+          type: "string",
+          description:
+            "Explicit plan.json path (default: repository plan.json, then profile runner fallback)",
+        },
         onlyItem: {
           type: "string",
           description: "Run gates for specific item only",
@@ -243,76 +459,38 @@ const tools = {
     },
     call: async (args) => {
       try {
-        // Resolve profile directory
-        const { resolveProfile } = await import("./dist/cli.js");
-        const resolved = resolveProfile(config.profileDir, process.cwd());
-
-        // Load plan
-        const planPath = resolve(resolved.path, "runner", "plan.json");
-        if (!existsSync(planPath)) {
-          throw new Error("No plan found. Run plan.create first.");
-        }
-
-        const { loadPlan, ExecutionState, executeGatesWithPolicy } = await import("./dist/cli.js");
-        const planContent = readFileSync(planPath, "utf-8");
-        const plan = loadPlan(planContent);
-
-        // Create execution state
-        const executionState = new ExecutionState(plan);
+        const artifact = new core.PlanArtifactService().resolve({
+          planFile: args.planFile,
+          workingDir: process.cwd(),
+          profileDir: config.profileDir,
+        });
 
         // Determine output directory
-        const outDir = args.outDir || resolve(resolved.path, "runner", "gates");
-
-        // Execute gates
-        await executeGatesWithPolicy(plan, executionState, outDir);
-
-        // Get results
-        const results = executionState.getResults();
-        const items = [];
-        let allGreen = true;
-
-        for (const [itemName, nodeResult] of results) {
-          // Filter by onlyItem if specified
-          if (args.onlyItem && itemName !== args.onlyItem) {
-            continue;
-          }
-
-          // Filter gates by onlyGate if specified
-          const gates =
-            nodeResult.gates
-              ?.filter((gate) => !args.onlyGate || gate.gate === args.onlyGate)
-              .map((gate) => ({
-                name: gate.gate,
-                status: gate.status,
-              })) || [];
-
-          items.push({
-            name: itemName,
-            status: nodeResult.status || "unknown",
-            gates: gates,
-          });
-
-          if (nodeResult.status !== "pass") {
-            allGreen = false;
-          }
-        }
-
-        const result = {
-          items,
-          allGreen,
-          outDir,
-        };
+        const outDir = args.outDir || resolve(dirname(artifact.filePath), "gates");
+
+        const summary = (
+          await new core.GateExecutionService().run({
+            plan: artifact.plan,
+            artifactDir: outDir,
+            onlyItem: args.onlyItem,
+            onlyGate: args.onlyGate,
+            options: { emitReceipt: false, suppressStdout: true },
+          })
+        ).summary;
+        const result = { ...summary, planArtifact: artifact.identity };
 
         return {
           content: [
             {
               type: "text",
-              text: `Gates execution complete:\n${JSON.stringify(result, null, 2)}`,
+              text: JSON.stringify(result, null, 2),
             },
           ],
         };
       } catch (error) {
-        throw new Error(`Failed to run gates: ${error.message}`);
+        const validationFailure = planValidationToolResult(error);
+        if (validationFailure) return validationFailure;
+        throw sharedServiceError(error, "gates.run", "GATE_EXECUTION_FAILED");
       }
     },
   },
@@ -322,6 +500,11 @@ const tools = {
     inputSchema: {
       type: "object",
       properties: {
+        planFile: {
+          type: "string",
+          description:
+            "Explicit plan.json path (default: repository plan.json, then profile runner fallback)",
+        },
         dryRun: {
           type: "boolean",
           description: "Simulate merge without making changes",
@@ -331,61 +514,42 @@ const tools = {
     },
     call: async (args) => {
       try {
-        // Check if mutations are allowed
-        if (!config.allowMutations && !args.dryRun) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Mutations not allowed. Set ALLOW_MUTATIONS=true or use dryRun=true.`,
-              },
-            ],
-          };
-        }
-
-        // Resolve profile directory
-        const { resolveProfile } = await import("./dist/cli.js");
-        const resolved = resolveProfile(config.profileDir, process.cwd());
-
-        // Load plan
-        const planPath = resolve(resolved.path, "runner", "plan.json");
-        if (!existsSync(planPath)) {
-          throw new Error("No plan found. Run plan.create first.");
-        }
-
-        const { loadPlan, ExecutionState, MergeEligibilityEvaluator } =
-          await import("./dist/cli.js");
-        const planContent = readFileSync(planPath, "utf-8");
-        const plan = loadPlan(planContent);
-
-        const executionState = new ExecutionState(plan);
-        const evaluator = new MergeEligibilityEvaluator(plan, executionState);
-        const decisions = evaluator.evaluateAllNodes();
-        const summary = evaluator.getMergeSummary();
-
-        const result = {
-          allowed: config.allowMutations && !args.dryRun,
-          dryRun: args.dryRun || false,
-          eligible: summary.eligible.length,
-          failed: summary.failed.length,
-          blocked: summary.blocked.length,
-          message: args.dryRun
-            ? `Dry run: ${summary.eligible.length} items eligible, ${summary.failed.length} failed, ${summary.blocked.length} blocked`
-            : config.allowMutations
-              ? `Ready to merge ${summary.eligible.length} eligible items`
-              : "Mutations disabled. Set ALLOW_MUTATIONS=true to enable merging.",
-        };
+        const artifact = new core.PlanArtifactService().resolve({
+          planFile: args.planFile,
+          workingDir: process.cwd(),
+          profileDir: config.profileDir,
+        });
+
+        const summary = (
+          await new core.MergeApplicationService().run({
+            plan: artifact.plan,
+            workingDir: process.cwd(),
+            dryRun: args.dryRun ?? true,
+            mutationAuthorized: config.allowMutations,
+          })
+        ).summary;
+        const result = { ...summary, planArtifact: artifact.identity };
 
         return {
           content: [
             {
               type: "text",
-              text: `Merge evaluation complete:\n${JSON.stringify(result, null, 2)}`,
+              text: JSON.stringify(result, null, 2),
             },
           ],
         };
       } catch (error) {
-        throw new Error(`Failed to apply merge: ${error.message}`);
+        const validationFailure = planValidationToolResult(error);
+        if (validationFailure) return validationFailure;
+        if (error?.name === "MergeApplicationServiceError" && typeof error.code === "string") {
+          const { mcpToolError } = await import("./dist/errors/index.js");
+          throw new Error(
+            core.canonicalJSONStringify(
+              mcpToolError(error.code, error.message, { tool: "merge.apply" })
+            )
+          );
+        }
+        throw sharedServiceError(error, "merge.apply", "MERGE_APPLICATION_FAILED");
       }
     },
   },
@@ -404,27 +568,21 @@ const tools = {
     },
     call: async (args) => {
       try {
-        const { initLocalOverlay } = await import("./dist/cli.js");
-        const force = args.force ?? false;
-        const result = initLocalOverlay(process.cwd(), force);
-
-        const output = {
-          created: result.created,
-          path: result.path,
-          config: result.config,
-          copiedFiles: result.copiedFiles,
-        };
+        const output = new core.WorkspaceInitializationService().run({
+          baseDir: process.cwd(),
+          force: args.force,
+        });
 
         return {
           content: [
             {
               type: "text",
-              text: `Local overlay initialized:\n${JSON.stringify(output, null, 2)}`,
+              text: JSON.stringify(output, null, 2),
             },
           ],
         };
       } catch (error) {
-        throw new Error(`Failed to initialize local overlay: ${error.message}`);
+        throw sharedServiceError(error, "local.init", "WORKSPACE_INIT_FAILED");
       }
     },
   },
@@ -443,36 +601,27 @@ const tools = {
     },
     call: async (args) => {
       try {
-        const { resolveProfile } = await import("./dist/cli.js");
-        const profileDirOverride = args.profileDir || config.profileDir;
-        const resolved = resolveProfile(profileDirOverride, process.cwd());
-
-        const output = {
-          path: resolved.path,
-          source: resolved.source,
-          manifest: {
-            role: resolved.manifest.role,
-            name: resolved.manifest.name,
-            version: resolved.manifest.version,
-          },
-        };
+        const output = new core.ConfigurationQueryService().resolveProfile({
+          baseDir: process.cwd(),
+          profileDir: args.profileDir || config.profileDir,
+        });
 
         return {
           content: [
             {
               type: "text",
-              text: `Profile resolved:\n${JSON.stringify(output, null, 2)}`,
+              text: JSON.stringify(output, null, 2),
             },
           ],
         };
       } catch (error) {
-        throw new Error(`Failed to resolve profile: ${error.message}`);
+        throw sharedServiceError(error, "profile.resolve", "PROFILE_RESOLUTION_FAILED");
       }
     },
   },
 
   health: {
-    description: "Get health status of the system with optional metrics",
+    description: "DEPRECATED: use doctor. Compatibility alias scheduled for removal in 2.0.0.",
     inputSchema: {
       type: "object",
       properties: {
@@ -485,42 +634,52 @@ const tools = {
     },
     call: async (args) => {
       try {
-        const { healthChecker } = await import("./dist/cli.js");
-        const health = healthChecker.getHealth(args.includeMetrics || false);
+        const doctor = await new core.WorkspaceDiagnosticsService().run({
+          baseDir: process.cwd(),
+          environmentQuality: args.includeMetrics,
+        });
+        const health = {
+          ...doctor,
+          deprecation: { tool: "health", replacement: "doctor", removeIn: "2.0.0" },
+        };
 
         return {
           content: [
             {
               type: "text",
-              text: `Health check:\n${JSON.stringify(health, null, 2)}`,
+              text: JSON.stringify(health, null, 2),
             },
           ],
         };
       } catch (error) {
-        throw new Error(`Failed to get health status: ${error.message}`);
+        throw sharedServiceError(error, "health", "WORKSPACE_DIAGNOSTICS_FAILED");
       }
     },
   },
 
   "lexrunner.startRun": {
-    description: "Start a new LexRunner procedure run and return a runId",
+    description: `DEPRECATED IntegrationRun record adapter; not ADR-010 orchestration authority. Use ${core.INTEGRATION_RECORD_REPLACEMENTS["lexrunner.startRun"]}. Remove in ${core.INTEGRATION_RECORD_REMOVAL_VERSION}.`,
     inputSchema: {
       type: "object",
       properties: {
         mode: {
           type: "string",
+          maxLength: 1024,
           description: "Persona mode (e.g., 'senior-dev', 'eager-pm')",
         },
         procedure: {
           type: "string",
+          maxLength: 1024,
           description: "Procedure identifier (e.g., 'merge-weave-main', 'pr-review')",
         },
         repo: {
           type: "string",
+          maxLength: 1024,
           description: "Repository in 'owner/repo' format",
         },
         task: {
           type: "string",
+          maxLength: 1024,
           description: "Human-readable task description",
         },
         params: {
@@ -532,9 +691,7 @@ const tools = {
     },
     call: async (args) => {
       try {
-        const { createRunManager } = await import("./dist/cli.js");
-        const manager = createRunManager();
-        const result = manager.startRun(args);
+        const result = new core.IntegrationRecordCompatibilityService(process.cwd()).start(args);
 
         return {
           content: [
@@ -545,18 +702,23 @@ const tools = {
           ],
         };
       } catch (error) {
-        throw new Error(`Failed to start run: ${error.message}`);
+        throw sharedServiceError(
+          error,
+          "lexrunner.startRun",
+          "INTEGRATION_RECORD_OPERATION_FAILED"
+        );
       }
     },
   },
 
   "lexrunner.getStatus": {
-    description: "Get current run state, summary, and next available actions",
+    description: `DEPRECATED bounded IntegrationRun record status; not ADR-010 Run status. Use ${core.INTEGRATION_RECORD_REPLACEMENTS["lexrunner.getStatus"]}. Remove in ${core.INTEGRATION_RECORD_REMOVAL_VERSION}.`,
     inputSchema: {
       type: "object",
       properties: {
         runId: {
           type: "string",
+          maxLength: 1024,
           description: "Unique run identifier",
         },
       },
@@ -564,9 +726,9 @@ const tools = {
     },
     call: async (args) => {
       try {
-        const { createRunManager } = await import("./dist/cli.js");
-        const manager = createRunManager();
-        const status = manager.getStatus(args);
+        const status = new core.IntegrationRecordCompatibilityService(process.cwd()).getStatus(
+          args
+        );
 
         return {
           content: [
@@ -577,18 +739,23 @@ const tools = {
           ],
         };
       } catch (error) {
-        throw new Error(`Failed to get status: ${error.message}`);
+        throw sharedServiceError(
+          error,
+          "lexrunner.getStatus",
+          "INTEGRATION_RECORD_OPERATION_FAILED"
+        );
       }
     },
   },
 
   "lexrunner.listArtifacts": {
-    description: "List and inspect artifacts and receipts for a run",
+    description: `DEPRECATED bounded IntegrationRun artifact metadata; never ADR-010 evidence authority. Use ${core.INTEGRATION_RECORD_REPLACEMENTS["lexrunner.listArtifacts"]}. Remove in ${core.INTEGRATION_RECORD_REMOVAL_VERSION}.`,
     inputSchema: {
       type: "object",
       properties: {
         runId: {
           type: "string",
+          maxLength: 1024,
           description: "Unique run identifier",
         },
         type: {
@@ -598,6 +765,7 @@ const tools = {
         },
         path: {
           type: "string",
+          maxLength: 1024,
           description: "Filter by path pattern (supports * and ** wildcards)",
         },
         latestOnly: {
@@ -606,16 +774,16 @@ const tools = {
         },
         inline: {
           type: "boolean",
-          description: "Include content for small artifacts (< 10KB)",
+          description: "Deprecated and ignored; compatibility responses never inline content",
         },
       },
       required: ["runId"],
     },
     call: async (args) => {
       try {
-        const { createRunManager } = await import("./dist/cli.js");
-        const manager = createRunManager();
-        const result = manager.listArtifacts(args);
+        const result = new core.IntegrationRecordCompatibilityService(process.cwd()).listArtifacts(
+          args
+        );
 
         return {
           content: [
@@ -626,7 +794,11 @@ const tools = {
           ],
         };
       } catch (error) {
-        throw new Error(`Failed to list artifacts: ${error.message}`);
+        throw sharedServiceError(
+          error,
+          "lexrunner.listArtifacts",
+          "INTEGRATION_RECORD_OPERATION_FAILED"
+        );
       }
     },
   },
@@ -663,7 +835,7 @@ const tools = {
     },
     call: async (args) => {
       try {
-        const { createGitHubAPI, GitHubAPI } = await import("./dist/cli.js");
+        const { createGitHubAPI, GitHubAPI, DiscoveryQueryService } = await import("./dist/cli.js");
 
         let githubAPI = await createGitHubAPI();
 
@@ -682,53 +854,17 @@ const tools = {
           );
         }
 
-        // Check authentication
-        const authStatus = await githubAPI.checkAuth();
-
-        // Fetch pull requests
-        const state = args.state || "open";
-        const pullRequests = await githubAPI.discoverPullRequests(state);
-
-        let result;
-
-        if (args.suggest) {
-          const { createFileAnalyzer } = await import("./dist/cli.js");
-
-          const analyzer = createFileAnalyzer(
-            githubAPI.getOctokit(),
-            githubAPI.config.owner,
-            githubAPI.config.repo
-          );
-          const prs = pullRequests.map((pr) => ({
-            number: pr.number,
-            name: `PR-${pr.number}`,
-            sha: pr.sha,
-          }));
-
-          const suggestions = await analyzer.suggestDependenciesWithHeuristics(prs);
-
-          result = {
-            pullRequests,
-            suggestions,
-            total: pullRequests.length,
-            suggestionsCount: suggestions.length,
-            authenticated: authStatus.authenticated,
-            user: authStatus.user,
-          };
-        } else {
-          result = {
-            pullRequests,
-            total: pullRequests.length,
-            authenticated: authStatus.authenticated,
-            user: authStatus.user,
-          };
-        }
+        const result = await new DiscoveryQueryService().run({
+          github: githubAPI,
+          state: args.state || "open",
+          suggest: args.suggest,
+        });
 
         return {
           content: [
             {
               type: "text",
-              text: `Pull requests discovered:\n${JSON.stringify(result, null, 2)}`,
+              text: JSON.stringify(result, null, 2),
             },
           ],
         };
@@ -745,48 +881,35 @@ const tools = {
       properties: {
         planFile: {
           type: "string",
-          description: "Path to plan.json file (default: plan.json)",
-          default: "plan.json",
+          description:
+            "Explicit plan.json path (default: repository plan.json, then profile runner fallback)",
         },
       },
     },
     call: async (args) => {
       try {
-        const planFile = args.planFile || "plan.json";
-
-        if (!existsSync(planFile)) {
-          throw new Error(`Plan file not found: ${planFile}`);
-        }
-
-        const { loadPlan, ExecutionState, MergeEligibilityEvaluator } =
-          await import("./dist/cli.js");
-        const planContent = readFileSync(planFile, "utf-8");
-        const plan = loadPlan(planContent);
-
-        const executionState = new ExecutionState(plan);
-        const evaluator = new MergeEligibilityEvaluator(plan, executionState);
-        const mergeSummary = evaluator.getMergeSummary();
-
+        const artifact = new core.PlanArtifactService().resolve({
+          planFile: args.planFile,
+          workingDir: process.cwd(),
+          profileDir: config.profileDir,
+        });
         const result = {
-          plan: {
-            schemaVersion: plan.schemaVersion,
-            target: plan.target,
-            itemCount: plan.items.length,
-            policy: plan.policy,
-          },
-          mergeSummary,
+          ...new core.IntegrationStatusQueryService().run(artifact.plan),
+          planArtifact: artifact.identity,
         };
 
         return {
           content: [
             {
               type: "text",
-              text: `Plan status:\n${JSON.stringify(result, null, 2)}`,
+              text: JSON.stringify(result, null, 2),
             },
           ],
         };
       } catch (error) {
-        throw new Error(`Failed to get status: ${error.message}`);
+        const validationFailure = planValidationToolResult(error);
+        if (validationFailure) return validationFailure;
+        throw sharedServiceError(error, "status", "INTEGRATION_STATUS_FAILED");
       }
     },
   },
@@ -799,112 +922,21 @@ const tools = {
     },
     call: async (args) => {
       try {
-        const {
-          bootstrapWorkspace,
-          detectProjectType,
-          getEnvironmentSuggestions,
-          createGitHubAPI,
-          createGitOperations,
-        } = await import("./dist/cli.js");
-
-        const checks = {
-          hasErrors: false,
-          issues: [],
-          suggestions: [],
-        };
-
-        // Node.js version check
-        try {
-          const nvmrcContent = readFileSync(".nvmrc", "utf-8").trim();
-          const currentVersion = process.version.slice(1);
-          const expectedVersion = nvmrcContent;
-
-          if (currentVersion === expectedVersion) {
-            checks.nodejs = {
-              status: "ok",
-              current: process.version,
-              expected: `v${expectedVersion}`,
-            };
-          } else {
-            checks.nodejs = {
-              status: "mismatch",
-              current: process.version,
-              expected: `v${expectedVersion}`,
-            };
-            checks.hasErrors = true;
-            checks.issues.push(
-              `Node.js version mismatch: ${process.version} vs v${expectedVersion}`
-            );
-          }
-        } catch {
-          checks.nodejs = {
-            status: "no_constraint",
-            current: process.version,
-          };
-          checks.suggestions.push("Consider adding .nvmrc file for Node.js version consistency");
-        }
-
-        // Configuration check
-        const bootstrap = bootstrapWorkspace();
-        checks.configuration = {
-          hasConfiguration: bootstrap.hasConfiguration,
-          missingFiles: bootstrap.missingFiles,
-          suggestions: bootstrap.suggestions,
-        };
-
-        // Project type detection
-        checks.projectType = detectProjectType();
-
-        // Environment suggestions
-        checks.environmentSuggestions = getEnvironmentSuggestions();
-
-        // GitHub integration check
-        try {
-          const githubAPI = await createGitHubAPI();
-          if (githubAPI) {
-            const authStatus = await githubAPI.checkAuth();
-            checks.github = {
-              detected: true,
-              authenticated: authStatus.authenticated,
-              user: authStatus.user,
-            };
-          } else {
-            checks.github = { detected: false };
-          }
-        } catch (error) {
-          checks.github = { detected: false, error: error.message };
-        }
-
-        // Git operations check
-        try {
-          const gitOps = createGitOperations();
-          const isClean = await gitOps.isClean();
-          const currentBranch = await gitOps.getCurrentBranch();
-
-          checks.git = {
-            status: "ok",
-            isClean,
-            currentBranch,
-          };
-        } catch (error) {
-          checks.git = {
-            status: "error",
-            error: error.message,
-          };
-          checks.hasErrors = true;
-          checks.issues.push(`Git operations failed: ${error.message}`);
-        }
+        const checks = await new core.WorkspaceDiagnosticsService().run({
+          baseDir: process.cwd(),
+          environmentQuality: args.environmentQuality,
+        });
 
         return {
           content: [
             {
               type: "text",
-              text: `Doctor checks:\n${JSON.stringify(checks, null, 2)}`,
+              text: JSON.stringify(checks, null, 2),
             },
           ],
         };
       } catch (error) {
-        throw new Error(`Failed to run doctor: ${error.message}`);
+        throw sharedServiceError(error, "doctor", "WORKSPACE_DIAGNOSTICS_FAILED");
       }
     },
   },
@@ -916,42 +948,35 @@ const tools = {
       properties: {
         planFile: {
           type: "string",
-          description: "Path to plan.json file (default: plan.json)",
-          default: "plan.json",
+          description:
+            "Explicit plan.json path (default: repository plan.json, then profile runner fallback)",
         },
       },
     },
     call: async (args) => {
       try {
-        const planFile = args.planFile || "plan.json";
-
-        if (!existsSync(planFile)) {
-          throw new Error(`Plan file not found: ${planFile}`);
-        }
-
-        const { loadPlan, computeMergeOrder } = await import("./dist/cli.js");
-        const planContent = readFileSync(planFile, "utf-8");
-        const plan = loadPlan(planContent);
-
-        // Compute merge order using Kahn's algorithm
-        const levels = computeMergeOrder(plan);
-
+        const artifact = new core.PlanArtifactService().resolve({
+          planFile: args.planFile,
+          workingDir: process.cwd(),
+          profileDir: config.profileDir,
+        });
         const result = {
-          levels,
-          totalItems: plan.items.length,
-          maxParallelism: Math.max(...levels.map((level) => level.length)),
+          ...new core.MergeOrderQueryService().run(artifact.plan),
+          planArtifact: artifact.identity,
         };
 
         return {
           content: [
             {
               type: "text",
-              text: `Merge order:\n${JSON.stringify(result, null, 2)}`,
+              text: JSON.stringify(result, null, 2),
             },
           ],
         };
       } catch (error) {
-        throw new Error(`Failed to compute merge order: ${error.message}`);
+        const validationFailure = planValidationToolResult(error);
+        if (validationFailure) return validationFailure;
+        throw sharedServiceError(error, "merge-order", "MERGE_ORDER_FAILED");
       }
     },
   },
@@ -969,56 +994,24 @@ const tools = {
     },
     call: async (args) => {
       try {
-        const { loadInputs } = await import("./dist/cli.js");
-
-        // Load configuration with provenance tracking
-        const config = loadInputs();
-
-        const output = {
-          config: {
-            items: config.items,
-            target: config.target,
-            version: config.version,
-          },
-          provenance: config.provenance || {},
-          sources: config.sources.map((s) => ({
-            exists: s.exists,
-            file: s.file,
-          })),
-        };
-
-        // If specific key requested, extract just that value
-        if (args.key) {
-          const keys = args.key.split(".");
-          let value = output.config;
-          for (const k of keys) {
-            if (value && typeof value === "object" && k in value) {
-              value = value[k];
-            } else {
-              value = undefined;
-              break;
-            }
-          }
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Configuration:\n${JSON.stringify({ key: args.key, value }, null, 2)}`,
-              },
-            ],
-          };
-        }
+        const result = new core.ConfigurationQueryService().show({
+          baseDir: process.cwd(),
+          key: args.key,
+        });
+        const output = args.key
+          ? { contract: result.contract, ...result.configuration[0] }
+          : result;
 
         return {
           content: [
             {
               type: "text",
-              text: `Configuration:\n${JSON.stringify(output, null, 2)}`,
+              text: JSON.stringify(output, null, 2),
             },
           ],
         };
       } catch (error) {
-        throw new Error(`Failed to show config: ${error.message}`);
+        throw sharedServiceError(error, "config.show", "WORKSPACE_DIAGNOSTICS_FAILED");
       }
     },
   },
@@ -1064,6 +1057,30 @@ const tools = {
   },
 };
 
+function canonicalToolResult(result) {
+  return {
+    content: [{ type: "text", text: core.canonicalJSONStringify(result) }],
+  };
+}
+
+function planValidationToolResult(error) {
+  const failure = core.asPlanValidationFailure(error);
+  return failure ? canonicalToolResult(failure) : null;
+}
+
+async function mutationToolCall(action, call) {
+  if (!config.allowMutations) {
+    return canonicalToolResult({
+      ok: false,
+      error: {
+        code: "mutations_disabled",
+        message: `Mutations not allowed. Set ALLOW_MUTATIONS=true to ${action}.`,
+      },
+    });
+  }
+  return canonicalToolResult(await call());
+}
+
 // MCP Protocol handler - JSON-RPC 2.0 over stdio
 async function handleRequest(request) {
   const { id, method, params } = request;