@arii/boomtick-mcp 0.6.2 → 0.7.0

package/dist/tools/jules/create-session.js

@@ -4,16 +4,26 @@ export const CreateJulesSessionInputSchema = z.object({
     task: z.string(),
     branch: z.string().optional(),
     pr: z.number().optional(),
+    repo: z.string().optional(),
 });
 export async function createJulesSessionHandler(input) {
     let branch = input.branch;
     if (!branch && input.pr) {
-        const prData = await runTDCli(["gh", "view", input.pr.toString()]);
+        const ghArgs = ["gh", "view", input.pr.toString()];
+        if (input.repo) {
+            ghArgs.push("--repo", input.repo);
+        }
+        const prData = await runTDCli(ghArgs);
         branch = prData.pr.headRefName;
     }
     if (!branch) {
         branch = process.env.DEFAULT_BASE_BRANCH || "main";
     }
-    const output = await runTDCli(["agent", "dispatch", branch, input.task]);
+    const dispatchArgs = ["agent", "dispatch"];
+    if (input.repo) {
+        dispatchArgs.push("--repo", input.repo);
+    }
+    dispatchArgs.push(branch, input.task);
+    const output = await runTDCli(dispatchArgs);
     return parseJulesSession(output.session || output);
 }

package/dist/tools/jules/create-session.test.js

@@ -41,6 +41,13 @@ describe("createJulesSessionHandler", () => {
             "agent", "dispatch", "feature-x", "do work"
         ]);
     });
+    it("should create a session with repo parameter", async () => {
+        const result = await createJulesSessionHandler({ task: "do work", branch: "main", repo: "arii/portfolio" });
+        expect(result.id).toBe("1234567890");
+        expect(shell.runCommand).toHaveBeenCalledWith("td", [
+            "agent", "dispatch", "--repo", "arii/portfolio", "main", "do work"
+        ]);
+    });
     it("should create a session with PR number", async () => {
         vi.mocked(shell.runCommand).mockImplementation(async (cmd, args) => {
             if (args[1] === "view") {

package/dist/tools/repo.multi_exec.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { runTDCli } from "./jules/shared.js";
+export const MultiExecInputSchema = z.object({
+    command: z.string().describe("Shell command to execute sequentially across repositories"),
+    repos: z.array(z.string()).optional().describe("Optional list of repository names to target"),
+    continueOnError: z.boolean().optional().default(true).describe("Whether to continue execution if a repo command fails"),
+});
+export async function multiExecHandler(input) {
+    const args = MultiExecInputSchema.parse(input);
+    const cliArgs = ["multi-repo", "exec", args.command];
+    if (args.repos) {
+        for (const r of args.repos) {
+            cliArgs.push("-r", r);
+        }
+    }
+    if (args.continueOnError === false) {
+        cliArgs.push("--fail-fast");
+    }
+    const output = await runTDCli(cliArgs, "execute command across ecosystem repositories");
+    return output;
+}

package/dist/tools/repo.multi_exec.test.js

@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+import { multiExecHandler } from "./repo.multi_exec.js";
+describe("MultiExec Tool", () => {
+    it("should execute a command sequentially across repositories", async () => {
+        const res = await multiExecHandler({
+            command: "echo test-vitest-exec",
+            repos: ["arii/boomtick"],
+        });
+        expect(res.status).toBe("success");
+        expect(res.total_repos).toBe(1);
+        expect(res.results[0].stdout).toContain("test-vitest-exec");
+    });
+});

package/dist/tools/repo.read_agent_context.js

@@ -3,6 +3,7 @@ import { config } from "../config.js";
 import { execSync } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
+import { runTDCli } from "./jules/shared.js";
 export const loadStandaloneAgentContext = (repoRoot = process.cwd()) => {
     const configPath = path.join(repoRoot, "project_config.json");
     let projectConfig = {};
@@ -27,13 +28,74 @@ export const loadStandaloneAgentContext = (repoRoot = process.cwd()) => {
         config: projectConfig,
     };
 };
-export const ReadAgentContextInputSchema = z.object({});
-export async function readAgentContextHandler(_args) {
-    const context = loadStandaloneAgentContext(config.repoPath);
+export const ReadAgentContextInputSchema = z.object({
+    path: z.string().optional().describe("Local filesystem path to target repository root"),
+    repoPath: z.string().optional().describe("Alias for path to target repository root"),
+    repo: z.string().optional().describe("Repository name override (e.g. arii/portfolio or portfolio)"),
+    repos: z.array(z.string()).optional().describe("List of repository names to fetch context for"),
+    all: z.boolean().optional().describe("Whether to fetch context across all discovered ecosystem repositories"),
+});
+export async function readAgentContextHandler(args) {
+    // 1. Ecosystem / Multi-repo request
+    if (args.all || (args.repos && args.repos.length > 0)) {
+        const cliArgs = ["multi-repo", "status"];
+        if (args.repos) {
+            for (const r of args.repos) {
+                cliArgs.push("-r", r);
+            }
+        }
+        const output = await runTDCli(cliArgs, "fetch multi-repo context");
+        return {
+            status: "success",
+            ecosystem: true,
+            repos: output.repos ?? [],
+            total: output.total ?? (output.repos?.length ?? 0)
+        };
+    }
+    // 2. Specific repository name override
+    if (args.repo) {
+        let matchedPath;
+        try {
+            const output = await runTDCli(["multi-repo", "status", "-r", args.repo], "find target repository");
+            const matched = output.repos?.[0];
+            if (matched?.path) {
+                matchedPath = matched.path;
+            }
+        }
+        catch {
+            // Fallback to directory inspection if CLI is unavailable or not in TD workspace
+        }
+        if (!matchedPath) {
+            const repoName = args.repo.includes("/") ? args.repo.split("/")[1] : args.repo;
+            const cwdParent = path.resolve(process.cwd(), "..", repoName);
+            const configParent = path.resolve(config.repoPath, "..", repoName);
+            if (fs.existsSync(cwdParent)) {
+                matchedPath = cwdParent;
+            }
+            else if (fs.existsSync(configParent)) {
+                matchedPath = configParent;
+            }
+        }
+        if (matchedPath) {
+            const context = loadStandaloneAgentContext(matchedPath);
+            return {
+                status: "success",
+                repo: args.repo,
+                path: matchedPath,
+                ...context
+            };
+        }
+    }
+    // 3. Specific filesystem path
+    const targetPath = (args.path || args.repoPath) ? path.resolve(args.path || args.repoPath) : config.repoPath;
+    const context = loadStandaloneAgentContext(targetPath);
     const result = {
         status: "success",
         ...context
     };
+    if (args?.repo) {
+        result.repo = args.repo;
+    }
     delete result.submodules;
     if (result.config) {
         delete result.config.submodules;

package/dist/tools/repo.read_agent_context.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { loadStandaloneAgentContext } from "./repo.read_agent_context.js";
+import { loadStandaloneAgentContext, readAgentContextHandler } from "./repo.read_agent_context.js";
 describe("Standalone Agent Context Loader", () => {
     it("should load agent context without submodule references", () => {
         const context = loadStandaloneAgentContext(process.cwd());
@@ -7,4 +7,33 @@ describe("Standalone Agent Context Loader", () => {
         expect(context).toHaveProperty("gitCommit");
         expect(context).not.toHaveProperty("submodules");
     });
+    it("should handle readAgentContextHandler with default workspace", async () => {
+        const res = await readAgentContextHandler({});
+        expect(res.status).toBe("success");
+        expect(res).toHaveProperty("packageName");
+        expect(res).toHaveProperty("gitCommit");
+    });
+    it("readAgentContextHandler should accept optional repoPath argument", async () => {
+        const res = await readAgentContextHandler({ repoPath: process.cwd() });
+        expect(res).toHaveProperty("status", "success");
+        expect(res).toHaveProperty("packageName");
+        expect(res).toHaveProperty("gitCommit");
+    });
+    it("readAgentContextHandler should accept path argument", async () => {
+        const res = await readAgentContextHandler({ path: process.cwd() });
+        expect(res).toHaveProperty("status", "success");
+        expect(res).toHaveProperty("packageName");
+    });
+    it("readAgentContextHandler should accept repo argument", async () => {
+        const res = await readAgentContextHandler({ repo: "arii/tech-dancer" });
+        expect(res).toHaveProperty("status", "success");
+        expect(res).toHaveProperty("repo", "arii/tech-dancer");
+    });
+    it("should handle multi-repo context querying when all: true is passed", async () => {
+        const res = await readAgentContextHandler({ all: true });
+        expect(res.status).toBe("success");
+        expect(res.ecosystem).toBe(true);
+        expect(Array.isArray(res.repos)).toBe(true);
+        expect(res.repos.length).toBeGreaterThan(0);
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arii/boomtick-mcp",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "Boomtick MCP Guide: PR Rescue + Merge Conflict Agent",
   "repository": {
     "type": "git",

package/src/config/dynamic.ts

@@ -1,14 +1,15 @@
 import { execSync } from "child_process";
+import { findRepoRoot } from "./repo.js";
 
 let cachedDynamicConfig: any = null;
 
-export function initializeConfig() {
+export function initializeConfig(targetCwd?: string) {
   if (cachedDynamicConfig !== null) {
     return cachedDynamicConfig;
   }
 
   try {
-    const cwd = process.env.BOOMTICK_REPO_PATH || process.cwd();
+    const cwd = findRepoRoot(targetCwd);
     const cmd = `td config view`;
     const output = execSync(cmd, {
       cwd,

package/src/config/repo.ts

@@ -4,12 +4,8 @@ import { fileURLToPath } from "url";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-export function findRepoRoot(): string {
-  if (process.env.BOOMTICK_REPO_PATH) {
-    return process.env.BOOMTICK_REPO_PATH;
-  }
-
-  let current = process.cwd();
+export function findRepoRoot(startDir?: string): string {
+  let current = startDir || process.cwd();
   while (current !== path.parse(current).root) {
     if (
       fs.existsSync(path.join(current, "project_config.json")) ||
@@ -21,6 +17,10 @@ export function findRepoRoot(): string {
     current = path.dirname(current);
   }
 
+  if (process.env.BOOMTICK_REPO_PATH) {
+    return process.env.BOOMTICK_REPO_PATH;
+  }
+
   current = __dirname;
   while (current !== path.parse(current).root) {
     if (

package/src/config.test.ts

@@ -25,10 +25,11 @@ describe("config", () => {
       vi.mocked(execSync).mockReturnValue(JSON.stringify(mockConfig));
 
       const { initializeConfig } = await import("./config.js");
+      const { findRepoRoot } = await import("./config/repo.js");
       const result = initializeConfig();
 
       expect(execSync).toHaveBeenCalledWith("td config view", expect.objectContaining({
-        cwd: process.cwd()
+        cwd: findRepoRoot()
       }));
       expect(result).toEqual(mockConfig);
     });
@@ -133,10 +134,17 @@ describe("config", () => {
       expect(() => config.githubRepo).toThrow("GITHUB_REPO must be set via environment variable or project_config.json");
     });
 
-    it("should resolve repoPath from BOOMTICK_REPO_PATH or findRepoRoot fallback", async () => {
+    it("should resolve active workspace from process.cwd() over BOOMTICK_REPO_PATH when inside a repo", async () => {
       process.env.BOOMTICK_REPO_PATH = "/custom/repo/path";
       const { config } = await import("./config.js");
-      expect(config.repoPath).toBe("/custom/repo/path");
+      expect(config.repoPath).toBe(process.cwd().replace(/\/mcp$/, ""));
+    });
+
+    it("should fallback to BOOMTICK_REPO_PATH when process.cwd() is outside any repo", async () => {
+      process.env.BOOMTICK_REPO_PATH = "/custom/repo/path";
+      const { findRepoRoot } = await import("./config/repo.js");
+      const rootDir = process.platform === "win32" ? "C:\\" : "/";
+      expect(findRepoRoot(rootDir)).toBe("/custom/repo/path");
     });
 
     it("should resolve defaultBaseBranch, viteBasePath, and ghPath", async () => {

package/src/mcp/definitions.ts

@@ -1,41 +1,70 @@
 import { Tool, Prompt, Resource, ResourceTemplate } from "@modelcontextprotocol/sdk/types.js";
 import {
   HealthCheckInputJsonSchema,
+  HealthCheckResponseJsonSchema,
   SearchPRsInputJsonSchema,
   SearchPRsResponseJsonSchema,
   GetPrDiffInputJsonSchema,
   PrDiffResponseJsonSchema,
   CheckoutBranchInputJsonSchema,
+  CheckoutBranchResponseJsonSchema,
   GetMergeConflictFilesInputJsonSchema,
   GetMergeConflictFilesResponseJsonSchema,
   GetChangedFilesInputJsonSchema,
+  GetChangedFilesResponseJsonSchema,
   GetPackageScriptsInputJsonSchema,
+  GetPackageScriptsResponseJsonSchema,
   ReadCiLogsInputJsonSchema,
+  ReadCiLogsResponseJsonSchema,
   RepoLogsInputJsonSchema,
+  RepoLogsResponseJsonSchema,
   CreateBranchInputJsonSchema,
+  CreateBranchResponseJsonSchema,
   CreateRepairBranchInputJsonSchema,
+  CreateRepairBranchResponseJsonSchema,
+  CheckJulesStatusResponseJsonSchema,
   RunTestsInputJsonSchema,
   RunTestsResponseJsonSchema,
   CommitPatchInputJsonSchema,
+  CommitPatchResponseJsonSchema,
   OpenReplacementPrInputJsonSchema,
+  OpenReplacementPrResponseJsonSchema,
   CreatePullRequestInputJsonSchema,
+  CreatePullRequestResponseJsonSchema,
   CommentTriageSummaryInputJsonSchema,
+  CommentTriageSummaryResponseJsonSchema,
   GetPrInputJsonSchema,
+  GetPrResponseJsonSchema,
   IssueViewInputJsonSchema,
+  IssueViewResponseJsonSchema,
   IssueUpdateInputJsonSchema,
   IssueUpdateResponseJsonSchema,
   IssueCommentInputJsonSchema,
+  IssueCommentResponseJsonSchema,
   CreateIssueInputJsonSchema,
   CreateIssueResponseJsonSchema,
   GetCommandSchemaInputJsonSchema,
+  GetCommandSchemaResponseJsonSchema,
   ReadAgentContextInputJsonSchema as ReadAgentContextSchema,
+  ReadAgentContextResponseJsonSchema,
+  MultiExecInputJsonSchema,
+  MultiExecResponseJsonSchema,
   CreateJulesSessionInputJsonSchema,
   JulesSessionIdInputJsonSchema,
   JulesSendMessageInputJsonSchema,
+  JulesSendMessageResponseJsonSchema,
+  JulesGetMessagesResponseJsonSchema,
   JulesListSessionsInputJsonSchema,
+  JulesListSessionsResponseJsonSchema,
+  JulesSessionResponseJsonSchema,
+  JulesGetPrResponseJsonSchema,
+  JulesTriggerFeedbackResponseJsonSchema,
   GetPrReviewsInputJsonSchema,
+  GetPrReviewsResponseJsonSchema,
   GetPrCommitsInputJsonSchema,
+  GetPrCommitsResponseJsonSchema,
   GetWorkflowRunsInputJsonSchema,
+  GetWorkflowRunsResponseJsonSchema,
 } from "../tools/contract.js";
 
 export const MCP_PROMPTS: Prompt[] = [
@@ -78,12 +107,24 @@ export const MCP_RESOURCES: Resource[] = [
     mimeType: "text/markdown",
     description: "The agent contract specification file (.agents/AGENT_CONTRACT.md).",
   },
+  {
+    uri: "mcp://workspace/project-config",
+    name: "Project Configuration",
+    mimeType: "application/json",
+    description: "The project configuration (project_config.json).",
+  },
   {
     uri: "mcp://git/changed-files",
     name: "Git Changed Files",
     mimeType: "application/json",
     description: "List of changed files in the repository.",
   },
+  {
+    uri: "mcp://git/status",
+    name: "Git Status",
+    mimeType: "application/json",
+    description: "Current working directory git status.",
+  },
   {
     uri: "mcp://ci/latest-run",
     name: "Latest CI Run",
@@ -125,18 +166,12 @@ export const MCP_RESOURCE_TEMPLATES: ResourceTemplate[] = [
   },
 ];
 
-const DEFAULT_OUTPUT_SCHEMA = {
-  type: "object",
-  properties: {},
-  additionalProperties: true,
-} as const;
-
 const BASE_MCP_TOOLS: Tool[] = [
   {
     name: "boomtick.health",
     description: "Check the health and configuration of the MCP server.",
     inputSchema: HealthCheckInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: HealthCheckResponseJsonSchema as any,
   },
   {
     name: "github.search_open_prs",
@@ -146,9 +181,15 @@ const BASE_MCP_TOOLS: Tool[] = [
   },
   {
     name: "repo.read_agent_context",
-    description: "Read the full repository index including file tree, CLI schema, and MCP tools.",
+    description: "Read the repository index including metadata, model review chains, or multi-repo ecosystem status.",
     inputSchema: ReadAgentContextSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: ReadAgentContextResponseJsonSchema as any,
+  },
+  {
+    name: "repo.multi_exec",
+    description: "Execute a shell command sequentially across ecosystem repositories (or a filtered subset).",
+    inputSchema: MultiExecInputJsonSchema as any,
+    outputSchema: MultiExecResponseJsonSchema as any,
   },
   {
     name: "github.get_pr_diff",
@@ -160,7 +201,7 @@ const BASE_MCP_TOOLS: Tool[] = [
     name: "github.checkout_branch",
     description: "Checkout a specific branch in the repository or worktree.",
     inputSchema: CheckoutBranchInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: CheckoutBranchResponseJsonSchema as any,
   },
   {
     name: "github.get_merge_conflict_files",
@@ -172,43 +213,43 @@ const BASE_MCP_TOOLS: Tool[] = [
     name: "repo.get_changed_files",
     description: "Get the list of changed files between two refs.",
     inputSchema: GetChangedFilesInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: GetChangedFilesResponseJsonSchema as any,
   },
   {
     name: "repo.get_command_schema",
     description: "Retrieve a lightweight, targeted schema for a specific td subcommand. Use this instead of reading the entire cli-schema.json to save tokens.",
     inputSchema: GetCommandSchemaInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: GetCommandSchemaResponseJsonSchema as any,
   },
   {
     name: "repo.get_package_scripts",
     description: "Get the scripts defined in package.json.",
     inputSchema: GetPackageScriptsInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: GetPackageScriptsResponseJsonSchema as any,
   },
   {
     name: "repo.read_ci_logs",
     description: "Read CI logs for a given pull request.",
     inputSchema: ReadCiLogsInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: ReadCiLogsResponseJsonSchema as any,
   },
   {
     name: "repo.logs",
     description: "Stream or grep combined CI logs for all jobs in a pull request.",
     inputSchema: RepoLogsInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: RepoLogsResponseJsonSchema as any,
   },
   {
     name: "repo.create_branch",
     description: "Creates a new clean git branch from a target base branch.",
     inputSchema: CreateBranchInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: CreateBranchResponseJsonSchema as any,
   },
   {
     name: "repo.create_repair_branch",
     description: "Creates a fresh worktree and a new repair branch for an existing PR. This isolates the repair work from the main codebase.",
     inputSchema: CreateRepairBranchInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: CreateRepairBranchResponseJsonSchema as any,
   },
   {
     name: "repo.check_jules_status",
@@ -224,7 +265,7 @@ const BASE_MCP_TOOLS: Tool[] = [
         intervalMs: { type: "integer", description: "Polling interval in milliseconds." },
       },
     } as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: CheckJulesStatusResponseJsonSchema as any,
   },
   {
     name: "repo.run_tests",
@@ -236,55 +277,55 @@ const BASE_MCP_TOOLS: Tool[] = [
     name: "repo.commit_patch",
     description: "Commit verified repair changes in a worktree.",
     inputSchema: CommitPatchInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: CommitPatchResponseJsonSchema as any,
   },
   {
     name: "github.open_replacement_pr",
     description: "Open a new PR that replaces or repairs the original PR.",
     inputSchema: OpenReplacementPrInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: OpenReplacementPrResponseJsonSchema as any,
   },
   {
     name: "github.create_pull_request",
     description: "Creates a pull request on GitHub using the MCP server's integrated credentials. Bypasses terminal CLI constraints.",
     inputSchema: CreatePullRequestInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: CreatePullRequestResponseJsonSchema as any,
   },
   {
     name: "github.comment_triage_summary",
     description: "Comment on the original PR with a diagnosis and replacement link.",
     inputSchema: CommentTriageSummaryInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: CommentTriageSummaryResponseJsonSchema as any,
   },
   {
     name: "github.get_pr",
     description: "Get details of a GitHub PR including title, state, and URLs.",
     inputSchema: GetPrInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: GetPrResponseJsonSchema as any,
   },
   {
     name: "github.get_pr_reviews",
     description: "Get top-level reviews, verdicts, states, and bodies for a GitHub PR.",
     inputSchema: GetPrReviewsInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: GetPrReviewsResponseJsonSchema as any,
   },
   {
     name: "github.get_pr_commits",
     description: "List commits and commit metadata (SHAs, authors, messages) for a GitHub PR.",
     inputSchema: GetPrCommitsInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: GetPrCommitsResponseJsonSchema as any,
   },
   {
     name: "repo.get_workflow_runs",
     description: "List recent GitHub Actions workflow runs for the repository.",
     inputSchema: GetWorkflowRunsInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: GetWorkflowRunsResponseJsonSchema as any,
   },
   {
     name: "github.issue_view",
     description: "View details of a GitHub issue including title, body, and state.",
     inputSchema: IssueViewInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: IssueViewResponseJsonSchema as any,
   },
   {
     name: "github.issue_update",
@@ -296,7 +337,7 @@ const BASE_MCP_TOOLS: Tool[] = [
     name: "github.issue_comment",
     description: "Add a new comment to a GitHub issue.",
     inputSchema: IssueCommentInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: IssueCommentResponseJsonSchema as any,
   },
   {
     name: "github.create_issue",
@@ -308,49 +349,49 @@ const BASE_MCP_TOOLS: Tool[] = [
     name: "jules.create_session",
     description: "Create a Jules session that performs work externally and may generate a GitHub pull request.",
     inputSchema: CreateJulesSessionInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: JulesSessionResponseJsonSchema as any,
   },
   {
     name: "jules.get_session",
     description: "Get the status and details of a Jules session.",
     inputSchema: JulesSessionIdInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: JulesSessionResponseJsonSchema as any,
   },
   {
     name: "jules.send_message",
     description: "Send a message to an active Jules session.",
     inputSchema: JulesSendMessageInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: JulesSendMessageResponseJsonSchema as any,
   },
   {
     name: "jules.get_messages",
     description: "Get the message history of a Jules session.",
     inputSchema: JulesSessionIdInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: JulesGetMessagesResponseJsonSchema as any,
   },
   {
     name: "jules.list_sessions",
     description: "List all Jules sessions.",
     inputSchema: JulesListSessionsInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: JulesListSessionsResponseJsonSchema as any,
   },
   {
     name: "jules.cancel_session",
     description: "Cancel an ongoing Jules session.",
     inputSchema: JulesSessionIdInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: JulesSessionResponseJsonSchema as any,
   },
   {
     name: "jules.get_pr",
     description: "Get the generated pull request url associated with an active Jules agent session.",
     inputSchema: JulesSessionIdInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: JulesGetPrResponseJsonSchema as any,
   },
   {
     name: "jules.trigger_feedback",
     description: "Automatically collect CI status/logs for the PR associated with a Jules session and send them back as feedback.",
     inputSchema: JulesSessionIdInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: JulesTriggerFeedbackResponseJsonSchema as any,
   },
 ];
 

package/src/mcp/http.test.ts

@@ -18,6 +18,16 @@ describe("createMcpHttpServer", () => {
     }
   });
 
+  it("should respond with 200 on GET /health endpoint", async () => {
+    httpServerObj = createMcpHttpServer({ port: 0, mcpServer });
+    port = await httpServerObj.listen(0);
+
+    const res = await fetch(`http://localhost:${port}/health`);
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body).toEqual({ status: "ok", transport: "http" });
+  });
+
   it("should respond with RFC 9728 OAuth protected resource metadata on /.well-known/oauth-protected-resource", async () => {
     httpServerObj = createMcpHttpServer({ port: 0, mcpServer });
     port = await httpServerObj.listen(0);