@schoolai/shipyard-mcp 0.4.1 → 0.4.2

package/apps/server/dist/index.js

@@ -2,9 +2,11 @@
 import {
   GitHubAuthError,
   GitHubPRResponseSchema,
+  OriginPlatformValues,
   PLAN_INDEX_DOC_NAME,
   PlanStatusValues,
   TOOL_NAMES,
+  ThreadCommentSchema,
   YDOC_KEYS,
   addArtifact,
   addDeliverable,
@@ -15,19 +17,24 @@ import {
   createPlanUrlWithHistory,
   createPlanWebUrl,
   createUserResolver,
+  detectPlatform,
   extractDeliverables,
   extractTextFromCommentBody,
   formatDeliverablesForLLM,
   formatDiffCommentsForLLM,
   generateSessionToken,
   getArtifacts,
+  getClientInfo,
   getDeliverables,
+  getDisplayName,
   getGitHubUsername,
   getLinkedPRs,
   getLocalChanges,
+  getLocalDiffCommentById,
   getLocalDiffComments,
   getOctokit,
   getOrCreateDoc,
+  getPRReviewCommentById,
   getPRReviewComments,
   getPlanEvents,
   getPlanMetadata,
@@ -46,23 +53,29 @@ import {
   linkArtifactToDeliverable,
   linkPR,
   logPlanEvent,
+  parseCommentId,
   parseRepoString,
+  parseThreadId,
   parseThreads,
-  registryConfig,
   releaseHubLock,
+  replyToLocalDiffComment,
+  replyToPRReviewComment,
   resetPlanToDraft,
+  setClientInfo,
   setPlanIndexEntry,
   setPlanMetadata,
   startRegistryServer,
+  toPlainObject,
   touchPlanIndexEntry,
   transitionPlanStatus,
   tryAcquireHubLock,
   uploadArtifact,
   webConfig
-} from "./chunk-6EWQC5VA.js";
+} from "./chunk-6TW62VVK.js";
 import {
-  logger
-} from "./chunk-HFZCBGQ3.js";
+  logger,
+  registryConfig
+} from "./chunk-DLDKEWOB.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -81,7 +94,7 @@ import * as os from "os";
 import * as path from "path";
 import * as vm from "vm";
 import ffmpegInstaller from "@ffmpeg-installer/ffmpeg";
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 
 // src/tools/add-artifact.ts
 import { writeFile as writeFile2 } from "fs/promises";
@@ -110,7 +123,6 @@ import { nanoid } from "nanoid";
 
 // src/local-artifacts.ts
 import { mkdir, readFile, rm, writeFile } from "fs/promises";
-import { homedir } from "os";
 import { join, resolve, sep } from "path";
 async function storeLocalArtifact(planId, filename, buffer) {
   const planDir = join(ARTIFACTS_DIR, planId);
@@ -138,7 +150,7 @@ async function deleteLocalArtifact(artifactId) {
     return false;
   }
 }
-var ARTIFACTS_DIR = join(homedir(), ".shipyard", "artifacts");
+var ARTIFACTS_DIR = join(registryConfig.SHIPYARD_STATE_DIR, "artifacts");
 
 // src/tools/artifact-helpers.ts
 async function resolveArtifactContent(input) {
@@ -706,10 +718,9 @@ async function handleAutoComplete(doc, metadata, deliverables, actorName, taskId
     actorName,
     snapshotMessage: "Task completed - all deliverables fulfilled"
   });
-  const { homedir: homedir2 } = await import("os");
   const { join: join3 } = await import("path");
   const { mkdir: mkdir2 } = await import("fs/promises");
-  const snapshotsDir = join3(homedir2(), ".shipyard", "snapshots");
+  const snapshotsDir = join3(registryConfig.SHIPYARD_STATE_DIR, "snapshots");
   await mkdir2(snapshotsDir, { recursive: true });
   const snapshotFile = join3(snapshotsDir, `${taskId}.txt`);
   await writeFile2(snapshotFile, result.snapshotUrl, "utf-8");
@@ -958,7 +969,7 @@ import { ServerBlockNoteEditor as ServerBlockNoteEditor3 } from "@blocknote/serv
 import { nanoid as nanoid2 } from "nanoid";
 import open from "open";
 import { z as z4 } from "zod";
-var OriginPlatformEnum = z4.enum(["devin", "cursor", "windsurf", "aider", "unknown"]);
+var OriginPlatformEnum = z4.enum(OriginPlatformValues);
 var CreateTaskInput = z4.object({
   title: z4.string().describe("Task title"),
   content: z4.string().describe("Task content (markdown)"),
@@ -986,8 +997,15 @@ function buildOriginMetadata(platform, sessionId, metadata) {
         generationId: typeof generationId === "string" ? generationId : void 0
       };
     }
-    case "windsurf":
     case "aider":
+    case "browser":
+    case "claude-code":
+    case "cline":
+    case "codex":
+    case "continue":
+    case "vscode":
+    case "windsurf":
+    case "zed":
     case "unknown":
       return { platform: "unknown", cwd: process.cwd() };
     default: {
@@ -1064,7 +1082,7 @@ Bad deliverables (not provable):
         prNumber: { type: "number", description: "PR number. Required for artifact uploads." },
         originPlatform: {
           type: "string",
-          enum: ["devin", "cursor", "windsurf", "aider", "unknown"],
+          enum: [...OriginPlatformValues],
           description: "Platform where this plan originated. Used for conversation export/import."
         },
         originSessionId: {
@@ -1688,11 +1706,10 @@ function formatThread(thread, number, selectedTextMaxLength, resolveUser) {
     const bodyText = extractTextFromCommentBody(comment.body);
     const authorName = resolveUser ? resolveUser(comment.userId) : comment.userId.slice(0, 8);
     if (idx === 0) {
-      output += `> **${authorName}:** ${bodyText}
+      output += `[thread:${thread.id}] **${authorName}:** ${bodyText}
 `;
     } else {
-      output += `>
-> **${authorName} (Reply):** ${bodyText}
+      output += `[comment:${comment.id}] **${authorName} (Reply):** ${bodyText}
 `;
     }
   });
@@ -2076,11 +2093,307 @@ Use this token for add_artifact, read_task, link_pr, and other task operations.`
   }
 };
 
-// src/tools/setup-review-notification.ts
+// src/tools/reply-to-diff-comment.ts
 import { z as z10 } from "zod";
-var SetupReviewNotificationInput = z10.object({
-  taskId: z10.string().describe("Task ID to monitor"),
-  pollIntervalSeconds: z10.number().optional().default(30).describe("Polling interval in seconds (default: 30)")
+var ReplyToDiffCommentInput = z10.object({
+  taskId: z10.string().describe("Plan ID"),
+  sessionToken: z10.string().describe("Session token from create_plan"),
+  commentId: z10.string().describe("Comment ID (PR or local diff comment)"),
+  body: z10.string().describe("Reply text")
+});
+var replyToDiffCommentTool = {
+  definition: {
+    name: TOOL_NAMES.REPLY_TO_DIFF_COMMENT,
+    description: `Reply to a PR review comment or local diff comment.
+
+Allows AI to respond to code review feedback.
+Replies appear inline in the Changes tab with the original comment.
+
+USAGE:
+- commentId: Comment ID from readDiffComments output (format: [pr:abc123] or [local:abc123])
+- body: Reply text (markdown supported)
+
+The tool automatically detects whether the comment is a PR or local diff comment.
+
+EXAMPLE:
+reply_to_diff_comment({
+  taskId: "abc123",
+  sessionToken: "token",
+  commentId: "pr:xyz789",
+  body: "Good point! I'll add that validation in the next commit."
+})`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        taskId: { type: "string", description: "Plan ID" },
+        sessionToken: { type: "string", description: "Session token from create_plan" },
+        commentId: { type: "string", description: "Comment ID (PR or local)" },
+        body: { type: "string", description: "Reply text" }
+      },
+      required: ["taskId", "sessionToken", "commentId", "body"]
+    }
+  },
+  /**
+   * Complexity of 20 is acceptable here because the function handles:
+   * - Input validation and session verification
+   * - Comment ID parsing with type detection
+   * - Two distinct comment types (PR vs local) with separate error handling
+   * - Success/error responses for each code path
+   * Extracting helpers would fragment the error handling context.
+   */
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: Tool handler needs unified error handling for two comment types
+  handler: async (args) => {
+    const input = ReplyToDiffCommentInput.parse(args);
+    logger.info({ taskId: input.taskId, commentId: input.commentId }, "Replying to diff comment");
+    const ydoc = await getOrCreateDoc(input.taskId);
+    const metadata = getPlanMetadata(ydoc);
+    if (!metadata) {
+      return {
+        content: [{ type: "text", text: `Plan "${input.taskId}" not found.` }],
+        isError: true
+      };
+    }
+    if (!metadata.sessionTokenHash || !verifySessionToken(input.sessionToken, metadata.sessionTokenHash)) {
+      return {
+        content: [{ type: "text", text: `Invalid session token for plan "${input.taskId}".` }],
+        isError: true
+      };
+    }
+    const actorName = await getGitHubUsername();
+    const clientInfoName = getClientInfo();
+    const { platform } = detectPlatform(clientInfoName);
+    const agentDisplayName = getDisplayName(platform, actorName);
+    const parsed = parseCommentId(input.commentId);
+    logger.debug(
+      { inputCommentId: input.commentId, parsedType: parsed.type, parsedId: parsed.id },
+      "Parsed comment ID from input"
+    );
+    const prComment = parsed.type === "pr" || parsed.type === "unknown" ? getPRReviewCommentById(ydoc, parsed.id) : null;
+    if (prComment) {
+      try {
+        const reply = replyToPRReviewComment(
+          ydoc,
+          parsed.id,
+          input.body,
+          agentDisplayName,
+          actorName
+        );
+        logPlanEvent(ydoc, "comment_added", actorName, {
+          commentId: reply.id,
+          prNumber: prComment.prNumber
+        });
+        logger.info(
+          { taskId: input.taskId, commentId: reply.id, parentCommentId: parsed.id },
+          "PR review comment reply added"
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Reply added to PR review comment!
+
+Comment ID: ${reply.id}
+Parent Comment ID: ${parsed.id}
+PR: #${prComment.prNumber}
+File: ${prComment.path}:${prComment.line}
+
+The reply will appear in the Changes tab inline with the original comment.`
+            }
+          ]
+        };
+      } catch (error) {
+        logger.error({ error, commentId: parsed.id }, "Failed to reply to PR comment");
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${errorMessage}` }],
+          isError: true
+        };
+      }
+    }
+    const localComment = parsed.type === "local" || parsed.type === "unknown" ? getLocalDiffCommentById(ydoc, parsed.id) : null;
+    if (localComment) {
+      try {
+        const reply = replyToLocalDiffComment(
+          ydoc,
+          parsed.id,
+          input.body,
+          agentDisplayName,
+          actorName
+        );
+        logPlanEvent(ydoc, "comment_added", actorName, {
+          commentId: reply.id
+        });
+        logger.info(
+          { taskId: input.taskId, commentId: reply.id, parentCommentId: parsed.id },
+          "Local diff comment reply added"
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Reply added to local diff comment!
+
+Comment ID: ${reply.id}
+Parent Comment ID: ${parsed.id}
+File: ${localComment.path}:${localComment.line}
+
+The reply will appear in the Changes tab inline with the original comment.`
+            }
+          ]
+        };
+      } catch (error) {
+        logger.error({ error, commentId: parsed.id }, "Failed to reply to local comment");
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${errorMessage}` }],
+          isError: true
+        };
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Comment "${parsed.id}" not found in plan "${input.taskId}".${input.commentId !== parsed.id ? ` (parsed from input: "${input.commentId}")` : ""} Make sure the comment ID is correct and the comment exists.`
+        }
+      ],
+      isError: true
+    };
+  }
+};
+
+// src/tools/reply-to-thread-comment.ts
+import { nanoid as nanoid3 } from "nanoid";
+import { z as z11 } from "zod";
+var ReplyToThreadCommentInput = z11.object({
+  taskId: z11.string().describe("Plan ID"),
+  sessionToken: z11.string().describe("Session token from create_plan"),
+  threadId: z11.string().describe("Thread ID to reply to"),
+  body: z11.string().describe("Reply text")
+});
+var replyToThreadCommentTool = {
+  definition: {
+    name: TOOL_NAMES.REPLY_TO_THREAD_COMMENT,
+    description: `Reply to a BlockNote inline thread comment.
+
+Allows AI to respond to reviewer feedback on specific blocks.
+Replies appear in the comment thread sidebar.
+
+USAGE:
+- threadId: Thread ID from read_plan output (format: [thread:abc123])
+- body: Reply text (plain text or BlockNote structured content)
+
+EXAMPLE:
+reply_to_thread_comment({
+  taskId: "abc123",
+  sessionToken: "token",
+  threadId: "thread-xyz",
+  body: "Good point! I'll add that validation."
+})`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        taskId: { type: "string", description: "Plan ID" },
+        sessionToken: { type: "string", description: "Session token from create_plan" },
+        threadId: { type: "string", description: "Thread ID to reply to" },
+        body: { type: "string", description: "Reply text" }
+      },
+      required: ["taskId", "sessionToken", "threadId", "body"]
+    }
+  },
+  handler: async (args) => {
+    const input = ReplyToThreadCommentInput.parse(args);
+    logger.info({ taskId: input.taskId, threadId: input.threadId }, "Replying to thread comment");
+    const ydoc = await getOrCreateDoc(input.taskId);
+    const metadata = getPlanMetadata(ydoc);
+    if (!metadata) {
+      return {
+        content: [{ type: "text", text: `Plan "${input.taskId}" not found.` }],
+        isError: true
+      };
+    }
+    if (!metadata.sessionTokenHash || !verifySessionToken(input.sessionToken, metadata.sessionTokenHash)) {
+      return {
+        content: [{ type: "text", text: `Invalid session token for plan "${input.taskId}".` }],
+        isError: true
+      };
+    }
+    const actorName = await getGitHubUsername();
+    const clientInfoName = getClientInfo();
+    const { platform } = detectPlatform(clientInfoName);
+    const agentDisplayName = getDisplayName(platform, actorName);
+    const parsedThreadId = parseThreadId(input.threadId);
+    logger.debug({ inputThreadId: input.threadId, parsedThreadId }, "Parsed thread ID from input");
+    const reply = ThreadCommentSchema.parse({
+      id: nanoid3(),
+      userId: agentDisplayName,
+      body: input.body,
+      createdAt: Date.now()
+    });
+    let updateSucceeded = false;
+    ydoc.transact(
+      () => {
+        const threadsMap = ydoc.getMap(YDOC_KEYS.THREADS);
+        const threadDataRaw = threadsMap.get(parsedThreadId);
+        if (!threadDataRaw || typeof threadDataRaw !== "object") {
+          return;
+        }
+        const threadData = toPlainObject(threadDataRaw);
+        if (!threadData) {
+          return;
+        }
+        if (!("comments" in threadData)) {
+          return;
+        }
+        const existingComments = Array.isArray(threadData.comments) ? threadData.comments : [];
+        const updatedThread = {
+          ...threadData,
+          comments: [...existingComments, reply]
+        };
+        threadsMap.set(parsedThreadId, updatedThread);
+        logPlanEvent(ydoc, "comment_added", actorName, {
+          commentId: reply.id
+        });
+        updateSucceeded = true;
+      },
+      actorName ? { actor: actorName } : void 0
+    );
+    if (!updateSucceeded) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Thread "${parsedThreadId}" not found in plan "${input.taskId}".${input.threadId !== parsedThreadId ? ` (parsed from input: "${input.threadId}")` : ""}`
+          }
+        ],
+        isError: true
+      };
+    }
+    logger.info(
+      { taskId: input.taskId, threadId: parsedThreadId, commentId: reply.id },
+      "Thread reply added"
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Reply added to thread!
+
+Comment ID: ${reply.id}
+Thread ID: ${parsedThreadId}
+
+The reply will appear in the comments panel when viewing this plan.`
+        }
+      ]
+    };
+  }
+};
+
+// src/tools/setup-review-notification.ts
+import { z as z12 } from "zod";
+var SetupReviewNotificationInput = z12.object({
+  taskId: z12.string().describe("Task ID to monitor"),
+  pollIntervalSeconds: z12.number().optional().default(30).describe("Polling interval in seconds (default: 30)")
 });
 var setupReviewNotificationTool = {
   definition: {
@@ -2198,31 +2511,31 @@ The script:
 
 // src/tools/update-block-content.ts
 import { ServerBlockNoteEditor as ServerBlockNoteEditor5 } from "@blocknote/server-util";
-import { z as z11 } from "zod";
-var BlockOperationSchema = z11.discriminatedUnion("type", [
-  z11.object({
-    type: z11.literal("update"),
-    blockId: z11.string().describe("The block ID to update (from read_plan output)"),
-    content: z11.string().describe("New markdown content for this block")
+import { z as z13 } from "zod";
+var BlockOperationSchema = z13.discriminatedUnion("type", [
+  z13.object({
+    type: z13.literal("update"),
+    blockId: z13.string().describe("The block ID to update (from read_plan output)"),
+    content: z13.string().describe("New markdown content for this block")
   }),
-  z11.object({
-    type: z11.literal("insert"),
-    afterBlockId: z11.string().nullable().describe("Insert after this block ID (null = insert at beginning)"),
-    content: z11.string().describe("Markdown content to insert as new block(s)")
+  z13.object({
+    type: z13.literal("insert"),
+    afterBlockId: z13.string().nullable().describe("Insert after this block ID (null = insert at beginning)"),
+    content: z13.string().describe("Markdown content to insert as new block(s)")
   }),
-  z11.object({
-    type: z11.literal("delete"),
-    blockId: z11.string().describe("The block ID to delete")
+  z13.object({
+    type: z13.literal("delete"),
+    blockId: z13.string().describe("The block ID to delete")
   }),
-  z11.object({
-    type: z11.literal("replace_all"),
-    content: z11.string().describe("Complete markdown content to replace the entire plan")
+  z13.object({
+    type: z13.literal("replace_all"),
+    content: z13.string().describe("Complete markdown content to replace the entire plan")
   })
 ]);
-var UpdateBlockContentInput = z11.object({
-  taskId: z11.string().describe("The task ID to modify"),
-  sessionToken: z11.string().describe("Session token from create_task"),
-  operations: z11.array(BlockOperationSchema).min(1).describe("Array of operations to perform atomically")
+var UpdateBlockContentInput = z13.object({
+  taskId: z13.string().describe("The task ID to modify"),
+  sessionToken: z13.string().describe("Session token from create_task"),
+  operations: z13.array(BlockOperationSchema).min(1).describe("Array of operations to perform atomically")
 });
 var updateBlockContentTool = {
   definition: {
@@ -2483,15 +2796,15 @@ async function applyOperation(blocks, operation, editor) {
 
 // src/tools/update-task.ts
 import { ServerBlockNoteEditor as ServerBlockNoteEditor6 } from "@blocknote/server-util";
-import { nanoid as nanoid3 } from "nanoid";
-import { z as z12 } from "zod";
+import { nanoid as nanoid4 } from "nanoid";
+import { z as z14 } from "zod";
 function buildStatusTransition(targetStatus, actorName) {
   const now = Date.now();
   switch (targetStatus) {
     case "pending_review":
       return {
         status: "pending_review",
-        reviewRequestId: nanoid3()
+        reviewRequestId: nanoid4()
       };
     case "changes_requested":
       return {
@@ -2517,12 +2830,12 @@ function buildStatusTransition(targetStatus, actorName) {
       return null;
   }
 }
-var UpdateTaskInput = z12.object({
-  taskId: z12.string().describe("The task ID to update"),
-  sessionToken: z12.string().describe("Session token from create_task"),
-  title: z12.string().optional().describe("New title"),
-  status: z12.enum(["draft", "pending_review", "changes_requested", "in_progress", "completed"]).optional().describe("New status"),
-  tags: z12.array(z12.string()).optional().describe("Updated tags (replaces existing tags)")
+var UpdateTaskInput = z14.object({
+  taskId: z14.string().describe("The task ID to update"),
+  sessionToken: z14.string().describe("Session token from create_task"),
+  title: z14.string().optional().describe("New title"),
+  status: z14.enum(["draft", "pending_review", "changes_requested", "in_progress", "completed"]).optional().describe("New status"),
+  tags: z14.array(z14.string()).optional().describe("Updated tags (replaces existing tags)")
 });
 var updateTaskTool = {
   definition: {
@@ -2685,8 +2998,8 @@ function getToolResultText(result) {
   return typeof text === "string" ? text : "";
 }
 async function serializeError(error) {
-  const { z: z14 } = await import("zod");
-  if (error instanceof z14.ZodError) {
+  const { z: z16 } = await import("zod");
+  if (error instanceof z16.ZodError) {
     const formattedIssues = error.issues.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`).join("\n");
     const message2 = `Validation error:
 ${formattedIssues}`;
@@ -2720,7 +3033,7 @@ ${formattedIssues}`;
 }
 var BUNDLED_DOCS = `Execute TypeScript code that calls Shipyard APIs. Use this for multi-step workflows to reduce round-trips.
 
-\u26A0\uFE0F IMPORTANT LIMITATION: Dynamic imports (\`await import()\`) are NOT supported in the VM execution context. Use only the pre-provided functions in the execution environment (createTask, readTask, readDiffComments, updateTask, addArtifact, completeTask, updateBlockContent, linkPR, requestUserInput, regenerateSessionToken, postUpdate). All necessary APIs are already available in the sandbox.
+\u26A0\uFE0F IMPORTANT LIMITATION: Dynamic imports (\`await import()\`) are NOT supported in the VM execution context. Use only the pre-provided functions in the execution environment (createTask, readTask, readDiffComments, updateTask, addArtifact, completeTask, updateBlockContent, linkPR, replyToThreadComment, replyToDiffComment, requestUserInput, regenerateSessionToken, postUpdate). All necessary APIs are already available in the sandbox.
 
 ## Available APIs
 
@@ -2909,6 +3222,56 @@ console.log('Linked:', pr.title, pr.status);
 
 ---
 
+### replyToThreadComment(opts): Promise<string>
+Reply to a BlockNote inline thread comment.
+
+Parameters:
+- taskId (string): Task ID
+- sessionToken (string): Session token
+- threadId (string): Thread ID from readTask output (format: [thread:abc123])
+- body (string): Reply text
+
+Returns: Success message with comment ID and thread ID
+
+Example:
+\`\`\`typescript
+const result = await replyToThreadComment({
+  taskId,
+  sessionToken,
+  threadId: 'thread-xyz789',
+  body: 'Good point! I\\'ll add that validation.'
+});
+console.log(result); // "Reply added to thread!..."
+\`\`\`
+
+---
+
+### replyToDiffComment(opts): Promise<string>
+Reply to a PR review comment or local diff comment.
+
+Parameters:
+- taskId (string): Task ID
+- sessionToken (string): Session token
+- commentId (string): Comment ID from readDiffComments (format: [pr:abc123] or [local:abc123])
+- body (string): Reply text
+
+Returns: Success message with reply comment ID and parent comment ID
+
+Automatically detects whether the comment is a PR or local diff comment.
+
+Example:
+\`\`\`typescript
+const result = await replyToDiffComment({
+  taskId,
+  sessionToken,
+  commentId: 'pr:xyz789',
+  body: 'Good catch! I\\'ll fix that in the next commit.'
+});
+console.log(result); // "Reply added to PR review comment!..."
+\`\`\`
+
+---
+
 ### requestUserInput(opts): Promise<{ success, response?, status, reason? }>
 Request input from the user via browser modal.
 
@@ -3250,8 +3613,8 @@ const result = await addArtifact({
 return { taskId: task.taskId, snapshotUrl: result.snapshotUrl };
 \`\`\`
 `;
-var ExecuteCodeInput = z13.object({
-  code: z13.string().describe("TypeScript code to execute")
+var ExecuteCodeInput = z15.object({
+  code: z15.string().describe("TypeScript code to execute")
 });
 var scriptTracker = [];
 async function createTask(opts) {
@@ -3394,8 +3757,16 @@ async function setupReviewNotification(taskId, pollIntervalSeconds) {
   const script = scriptMatch?.[1] || "";
   return { script, fullResponse: text };
 }
+async function replyToThreadComment(opts) {
+  const result = await replyToThreadCommentTool.handler(opts);
+  return getToolResultText(result);
+}
+async function replyToDiffComment(opts) {
+  const result = await replyToDiffCommentTool.handler(opts);
+  return getToolResultText(result);
+}
 async function requestUserInput(opts) {
-  const { InputRequestManager } = await import("./input-request-manager-QT4IVCLS.js");
+  const { InputRequestManager } = await import("./input-request-manager-FK4REBEZ.js");
   const ydoc = await getOrCreateDoc(PLAN_INDEX_DOC_NAME);
   const manager = new InputRequestManager();
   if ("questions" in opts && opts.questions) {
@@ -3614,6 +3985,8 @@ var executeCodeTool = {
         completeTask,
         updateBlockContent,
         linkPR: linkPR2,
+        replyToThreadComment,
+        replyToDiffComment,
         requestUserInput,
         regenerateSessionToken,
         postUpdate,
@@ -3722,6 +4095,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
   tools: [executeCodeTool.definition]
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const clientInfo = server.getClientVersion();
+  if (clientInfo?.name) {
+    setClientInfo(clientInfo.name);
+    logger.info(
+      { clientName: clientInfo.name, clientVersion: clientInfo.version },
+      "MCP client info captured from tool call"
+    );
+  }
   const { name, arguments: args } = request.params;
   if (name === TOOL_NAMES.EXECUTE_CODE) {
     return await executeCodeTool.handler(args ?? {});

package/apps/server/dist/{input-request-manager-QT4IVCLS.js → input-request-manager-FK4REBEZ.js}

@@ -5,10 +5,10 @@ import {
   createMultiQuestionInputRequest,
   getOrCreateDoc,
   logPlanEvent
-} from "./chunk-6EWQC5VA.js";
+} from "./chunk-6TW62VVK.js";
 import {
   logger
-} from "./chunk-HFZCBGQ3.js";
+} from "./chunk-DLDKEWOB.js";
 
 // src/services/input-request-manager.ts
 function formatDuration(totalSeconds) {