@codazen/harmonica-mcp 0.29.0 → 0.30.0

package/dist/index.js

@@ -21877,7 +21877,7 @@ function formatBeatSummaryTable(beats) {
   });
   return [header, ...rows].join("\n");
 }
-function formatBeatDetail(beat, workItemNotes) {
+function formatBeatDetail(beat) {
   const sections = [];
   sections.push(`# ${beat.beatId}: ${beat.title}`);
   sections.push(`**Status:** ${resolveStatus(beat).replace("_", " ")}`);
@@ -21896,38 +21896,8 @@ ${beat.description}`);
   if (beat.priority != null) {
     sections.push(`**Priority:** ${beat.priority}`);
   }
-  if (workItemNotes && workItemNotes.length > 0) {
-    formatWorkItemNotes(sections, workItemNotes);
-  }
   return sections.join("\n");
 }
-function formatWorkItemNotes(sections, notes) {
-  const essentials = notes.filter((n) => n.workItemMeta?.scope === "essential");
-  const niceToHaves = notes.filter((n) => n.workItemMeta?.scope === "nice_to_have");
-  if (essentials.length > 0) {
-    const lines = essentials.filter((n) => n.workItemMeta).map((n) => {
-      const meta = n.workItemMeta;
-      const hours = meta.estimatedHoursRange ? ` [${meta.estimatedHoursRange}]` : "";
-      const check2 = meta.acceptanceCheck ? `
-  - _Check:_ ${meta.acceptanceCheck}` : "";
-      return `- **${n.content}** (${meta.category}, ${meta.complexity})${hours}${check2}`;
-    }).join("\n");
-    sections.push(`
-## Essentials (${essentials.length})
-${lines}`);
-  }
-  if (niceToHaves.length > 0) {
-    const lines = niceToHaves.filter((n) => n.workItemMeta).map((n) => {
-      const meta = n.workItemMeta;
-      const why = meta.whyOutOfScope ? `
-  - _Why out of scope:_ ${meta.whyOutOfScope}` : "";
-      return `- **${n.content}** (${meta.category}, ${meta.complexity})${why}`;
-    }).join("\n");
-    sections.push(`
-## Nice-to-Haves \u2014 Out of Scope (${niceToHaves.length})
-${lines}`);
-  }
-}
 
 // ../../libs/harmonica-services/src/mcp/formatters/project-formatter.ts
 function formatProjectSummaryTable(projects) {
@@ -21945,7 +21915,6 @@ var NOTE_TYPE_LABELS = {
   constraint: "Constraints",
   guidance: "Guidance",
   decision: "Decisions",
-  workItem: "Work Items",
   document: "Documents"
 };
 function formatProjectContext(project, notes, orgCoda) {
@@ -22042,7 +22011,6 @@ var TYPE_LABELS = {
   constraint: "Constraint",
   guidance: "Guidance",
   decision: "Decision",
-  workItem: "Work Item",
   document: "Document"
 };
 function formatNoteSummary(note) {
@@ -22127,15 +22095,6 @@ function formatNoteDetail(note) {
       parts.push(`- Criticality: ${note.criticality.toFixed(2)}`);
     }
   }
-  if (note.workItemMeta) {
-    parts.push("", "### Work Item Details");
-    parts.push(`- Category: ${note.workItemMeta.category}`);
-    parts.push(`- Complexity: ${note.workItemMeta.complexity}`);
-    parts.push(`- Scope: ${note.workItemMeta.scope}`);
-    if (note.workItemMeta.estimatedHoursRange) {
-      parts.push(`- Estimated Hours: ${note.workItemMeta.estimatedHoursRange}`);
-    }
-  }
   if (note.documentMeta) {
     parts.push("", "### Document Details");
     parts.push(`- Filename: ${note.documentMeta.originalFilename}`);
@@ -22168,6 +22127,7 @@ var TYPE_LABELS2 = {
 };
 var STATUS_LABELS = {
   running: "Running",
+  held: "Held",
   succeeded: "Succeeded",
   failed: "Failed",
   timed_out: "Timed Out",
@@ -22310,7 +22270,7 @@ function registerBeatTools(server, ctx, client) {
   );
   server.tool(
     "get_beat",
-    "Get full beat detail including description and work items",
+    "Get full beat detail including description",
     { beatId: external_exports.string().describe("The beat ID (e.g., TF-B-001)") },
     async ({ beatId }) => {
       await assertBeatInOrg(client, beatId, ctx.orgId);
@@ -22318,12 +22278,7 @@ function registerBeatTools(server, ctx, client) {
       if (!beat) {
         return { content: [{ type: "text", text: `Beat not found: "${beatId}"` }], isError: true };
       }
-      const workItemIndex = await client.listBeatNotes(beatId, { noteType: "workItem" });
-      const workItemNotes = await Promise.all(
-        workItemIndex.map((n) => client.getNote(n.noteId))
-      );
-      const validNotes = workItemNotes.filter((n) => n !== void 0);
-      const text = formatBeatDetail(beat, validNotes);
+      const text = formatBeatDetail(beat);
       return { content: [{ type: "text", text }] };
     }
   );
@@ -22681,6 +22636,15 @@ function registerBeatVersionTools(server, ctx, client) {
           createdBy: ctx.user.email,
           sourceType: "mcp_tool"
         });
+        if (!beatVersion?.beatVersionId || !beatVersion.title) {
+          return {
+            content: [{
+              type: "text",
+              text: `Beat Version was stored but the response is missing required fields (beatVersionId or title). Use list_beat_versions on beat "${beatId}" to find the newly created version.`
+            }],
+            isError: true
+          };
+        }
         const lines = [
           `Beat Version created successfully.`,
           "",
@@ -22844,6 +22808,34 @@ function registerBeatVersionTools(server, ctx, client) {
           `**Transition:** ${bv.status} \u2192 ${targetState}`
         ];
         if (reason) lines.push(`**Reason:** ${reason}`);
+        if (result.fanOutWarning) {
+          lines.push("");
+          lines.push(`\u26A0 Fan-out warning: ${result.fanOutWarning.message}`);
+        }
+        if (targetState === "building" && !bv.targetDropId) {
+          try {
+            const project = await client.getProject(bv.projectId);
+            const teamspaceId = project?.teamspaceId;
+            if (teamspaceId) {
+              const draftDrops = await client.listTeamspaceDrops(teamspaceId, { state: "draft" });
+              lines.push("");
+              if (draftDrops.length > 0) {
+                lines.push("\u26A0 **No Drop assigned.** This Beat Version has no target Drop. Assign it to track which release this work belongs to.");
+                lines.push("");
+                lines.push("Available draft Drops:");
+                for (const drop of draftDrops) {
+                  lines.push(`  \u2022 ${drop.dropCode} \u2014 ${drop.name} (${drop.dropId})`);
+                }
+                lines.push("");
+                lines.push("Use `update_beat_version` to set `targetDropId`, or call `add_beat_version_to_drop`.");
+              } else {
+                lines.push(`\u26A0 **No Drop assigned and no draft Drops exist in Teamspace \`${teamspaceId}\`.** Create a Drop first with \`create_drop\`, then assign this Beat Version to it.`);
+              }
+            }
+          } catch (err) {
+            console.warn("[drop-warning] drop lookup failed for Beat Version", beatVersionId, err);
+          }
+        }
         return { content: [{ type: "text", text: lines.join("\n") }] };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -23108,7 +23100,7 @@ var DROP_STATES = ["draft", "scheduled", "in_progress", "released", "rolled_back
 function registerDropTools(server, ctx, client) {
   server.tool(
     "list_drops",
-    "List Drops in a Teamspace, optionally filtered by lifecycle state and sorted. A Drop is a release container \u2014 different from a Beat (capability) or Revision (work item). Use this to see what releases are planned, in flight, or shipped.",
+    "List Drops in a Teamspace, optionally filtered by lifecycle state and sorted. A Drop is a release container \u2014 different from a Beat (capability) or Revision (PR-level increment). Use this to see what releases are planned, in flight, or shipped.",
     {
       teamspaceId: external_exports.string().describe("The teamspace ID"),
       state: external_exports.enum(DROP_STATES).optional().describe("Filter by a single Drop state (use status for multi-state OR filtering)"),
@@ -23433,7 +23425,7 @@ function registerEmbeddingTools(server, ctx, client) {
       limit: external_exports.coerce.number().int().min(1).max(50).optional().default(10).describe("Max results to return. Default 10"),
       includeArchived: external_exports.boolean().optional().default(false).describe("Include archived/deprecated entities in results (excluded by default)"),
       entityType: external_exports.enum(["note", "beat", "revision"]).optional().describe("Restrict results to a specific entity type"),
-      noteType: external_exports.enum(["context", "assumption", "constraint", "guidance", "decision", "workItem", "document"]).optional().describe("Restrict results to a specific note type (only applies when entityType is note or unset). Requires embeddings generated after this filter was introduced."),
+      noteType: external_exports.enum(["context", "assumption", "constraint", "guidance", "decision", "document"]).optional().describe("Restrict results to a specific note type (only applies when entityType is note or unset). Requires embeddings generated after this filter was introduced."),
       noteStatus: external_exports.enum(["active", "unvalidated", "validated", "invalidated", "inProgress", "resolved", "superseded", "dismissed"]).optional().describe("Restrict note results to a specific status (e.g. unvalidated). DynamoDB post-filter \u2014 works without re-embedding."),
       beatId: external_exports.string().optional().describe("Restrict note results to those belonging to a specific beat (DynamoDB post-filter, no re-embedding needed)")
     },
@@ -23807,7 +23799,7 @@ function formatTriageActions(actions) {
 }
 
 // ../../libs/harmonica-services/src/mcp/tools/note-tools.ts
-var NOTE_TYPE_VALUES = ["context", "assumption", "constraint", "guidance", "decision", "workItem", "document"];
+var NOTE_TYPE_VALUES = ["context", "assumption", "constraint", "guidance", "decision", "document"];
 var NOTE_STATUS_VALUES = ["active", "unvalidated", "validated", "invalidated", "inProgress", "resolved", "superseded", "dismissed"];
 function registerNoteTools(server, ctx, client) {
   server.tool(
@@ -23940,7 +23932,6 @@ function registerNoteTools(server, ctx, client) {
             rationale,
             createdBy: ctx.user.userId,
             aiGenerated: false,
-            humanAssignee: noteType === "workItem" ? { email: ctx.user.email, name: ctx.user.name } : void 0,
             affectsBeats,
             dependsOnNotes,
             assumptionMeta
@@ -23992,7 +23983,7 @@ ${text}` }] };
       content: external_exports.string().optional().describe("Updated content"),
       response: external_exports.string().optional().describe("User response (for resolving assumptions)"),
       beatId: external_exports.string().optional().describe("Move this note to a different beat (updates all index items transactionally)"),
-      revisionId: external_exports.string().optional().describe("Revision ID to associate this note with (primary use case: workItem notes; occasionally useful for revision-scoped assumptions or decisions)"),
+      revisionId: external_exports.string().optional().describe("Revision ID to associate this note with (revision-scoped assumptions, decisions, or guidance)"),
       dependsOnNotes: external_exports.array(external_exports.string()).optional().describe("Note IDs this note depends on (child \u2192 parent links for consolidation)"),
       humanAssignee: humanAssigneeSchema.nullable().optional().describe("Assign or reassign this note to a person (null to clear)"),
       agentAssignee: agentAssigneeSchema.nullable().optional().describe("Assign or reassign this note to an agent (null to clear)")
@@ -24252,7 +24243,7 @@ function registerOnboardingTools(server, ctx, client) {
   server.tool(
     "create_teamspace_onboarding_batch",
     [
-      "Create a Teamspace, Projects, Notes, Deliverables, and stakeholder workItems",
+      "Create a Teamspace, Projects, Notes, and Deliverables",
       "from a PM-approved onboarding payload in a single batch operation.",
       "Call this after the PM approves the pre-flight review card from initiate_teamspace_onboarding.",
       "Returns a creation receipt with IDs and counts for all created entities.",
@@ -24262,15 +24253,13 @@ function registerOnboardingTools(server, ctx, client) {
       teamspaceName: external_exports.string().min(1).max(200).describe("Teamspace display name"),
       projects: external_exports.array(OnboardingProjectInputSchema).min(1).describe("Phase 1 projects to create, each linked to the Teamspace"),
       teamspaceNotes: external_exports.array(OnboardingNoteInputSchema).describe("Constraints, assumptions, and context notes at the Teamspace/project level"),
-      deliverables: external_exports.array(OnboardingDeliverableInputSchema).describe("Deliverables detected from commitment language in documents"),
-      stakeholderWorkItems: external_exports.array(external_exports.string().min(1)).describe("Work item content strings for missing client stakeholder roles")
+      deliverables: external_exports.array(OnboardingDeliverableInputSchema).describe("Deliverables detected from commitment language in documents")
     },
     async ({
       teamspaceName,
       projects,
       teamspaceNotes,
-      deliverables,
-      stakeholderWorkItems
+      deliverables
     }) => {
       const lines = [];
       let teamspace;
@@ -24373,27 +24362,6 @@ Notes filed: ${createdNotes.length}`);
         }
       }
       lines.push(`Deliverables: ${createdDeliverables.length}`);
-      let workItemCount = 0;
-      if (stakeholderWorkItems.length > 0 && createdProjects.length > 0) {
-        const firstProjectId = createdProjects[0].projectId;
-        for (const content of stakeholderWorkItems) {
-          try {
-            await client.createNote({
-              noteId: `N-TEMP-${Date.now()}`,
-              // overridden server-side
-              projectId: firstProjectId,
-              noteType: "workItem",
-              content,
-              status: "active",
-              createdBy: ctx.user?.userId ?? "mcp",
-              aiGenerated: false
-            });
-            workItemCount++;
-          } catch {
-          }
-        }
-      }
-      lines.push(`Stakeholder workItems: ${workItemCount}`);
       lines.unshift(`\u2705 Onboarding batch created successfully.`);
       return { content: [{ type: "text", text: lines.join("\n") }] };
     }
@@ -24954,17 +24922,18 @@ function registerProjectTools(server, ctx, client) {
     "Get project metadata, description, and notes in one view",
     { projectId: external_exports.string().describe("The project ID") },
     async ({ projectId }) => {
-      await assertProjectInOrg(client, projectId, ctx.orgId);
-      const [project, org] = await Promise.all([
-        client.getProject(projectId),
-        client.getOrg(ctx.orgId)
-      ]);
-      if (!project) {
-        return { content: [{ type: "text", text: `Project not found: "${projectId}"` }], isError: true };
+      try {
+        const [project, org] = await Promise.all([
+          fetchProjectInOrg(client, projectId, ctx.orgId),
+          client.getOrg(ctx.orgId)
+        ]);
+        const notes = await client.listProjectNotes(projectId);
+        const text = formatProjectContext(project, notes, org?.coda);
+        return { content: [{ type: "text", text }] };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: `Failed to get project context: ${message}` }], isError: true };
       }
-      const notes = await client.listProjectNotes(projectId);
-      const text = formatProjectContext(project, notes, org?.coda);
-      return { content: [{ type: "text", text }] };
     }
   );
   server.tool(
@@ -24982,39 +24951,44 @@ function registerProjectTools(server, ctx, client) {
       rateLimitOverrides: external_exports.record(external_exports.string(), external_exports.object({ maxPerHour: external_exports.number().min(0) })).optional().describe('Per-task-type rate limit overrides, e.g. {"agent_chat":{"maxPerHour":100}}. Overrides env var and compiled defaults.')
     },
     async ({ projectId, ...updates }) => {
-      await assertProjectInOrg(client, projectId, ctx.orgId);
-      if (updates.teamspaceId != null) {
-        const teamspace = await client.getTeamspace(updates.teamspaceId);
-        if (!teamspace) {
-          return { content: [{ type: "text", text: "Teamspace not found" }], isError: true };
+      try {
+        const nonEmpty = Object.fromEntries(
+          Object.entries(updates).filter(([, v]) => v !== void 0)
+        );
+        if (Object.keys(nonEmpty).length === 0) {
+          return { content: [{ type: "text", text: "No updates provided." }], isError: true };
         }
-        if (teamspace.orgId !== ctx.orgId) {
-          return { content: [{ type: "text", text: "Teamspace does not belong to this organization" }], isError: true };
+        await assertProjectInOrg(client, projectId, ctx.orgId);
+        if (updates.teamspaceId != null) {
+          const teamspace = await client.getTeamspace(updates.teamspaceId);
+          if (!teamspace) {
+            return { content: [{ type: "text", text: "Teamspace not found" }], isError: true };
+          }
+          if (teamspace.orgId !== ctx.orgId) {
+            return { content: [{ type: "text", text: "Teamspace does not belong to this organization" }], isError: true };
+          }
         }
+        const updated = await client.updateProject(projectId, nonEmpty);
+        if (!updated) {
+          return { content: [{ type: "text", text: `Project not found: "${projectId}"` }], isError: true };
+        }
+        if (PROJECT_EMBEDDING_FIELDS.some((f) => f in nonEmpty)) {
+          void client.triggerProjectEmbedding(projectId);
+        }
+        const lines = [
+          `Project updated successfully.`,
+          "",
+          `**ID:** ${updated.projectId}`,
+          `**Title:** ${updated.title}`,
+          updated.strategy ? `**Strategy:** (updated)` : "",
+          updated.repoOwner ? `**Repo:** ${updated.repoOwner}/${updated.repoName}` : "",
+          updated.repoDefaultBranch ? `**Default Branch:** ${updated.repoDefaultBranch}` : ""
+        ].filter(Boolean);
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: `Failed to update project: ${message}` }], isError: true };
       }
-      const nonEmpty = Object.fromEntries(
-        Object.entries(updates).filter(([, v]) => v !== void 0)
-      );
-      if (Object.keys(nonEmpty).length === 0) {
-        return { content: [{ type: "text", text: "No updates provided." }], isError: true };
-      }
-      const updated = await client.updateProject(projectId, nonEmpty);
-      if (!updated) {
-        return { content: [{ type: "text", text: `Project not found: "${projectId}"` }], isError: true };
-      }
-      if (PROJECT_EMBEDDING_FIELDS.some((f) => f in nonEmpty)) {
-        void client.triggerProjectEmbedding(projectId);
-      }
-      const lines = [
-        `Project updated successfully.`,
-        "",
-        `**ID:** ${updated.projectId}`,
-        `**Title:** ${updated.title}`,
-        updated.strategy ? `**Strategy:** (updated)` : "",
-        updated.repoOwner ? `**Repo:** ${updated.repoOwner}/${updated.repoName}` : "",
-        updated.repoDefaultBranch ? `**Default Branch:** ${updated.repoDefaultBranch}` : ""
-      ].filter(Boolean);
-      return { content: [{ type: "text", text: lines.join("\n") }] };
     }
   );
   server.tool(
@@ -25111,13 +25085,13 @@ function registerProjectTools(server, ctx, client) {
 function registerRevisionLifecycleTools(server, ctx, client) {
   server.tool(
     "create_revision",
-    "Create a new revision on a Beat. Starts in `draft` state under the PR workflow (draft \u2192 open \u2192 merged) \u2014 NOT the standard Beat Version lifecycle. Transition to `open` when the PR is ready for review; transition to `merged` when the PR is merged. Environment progression (in_staging, ready_for_production, live) is tracked on the parent Beat Version, not the Revision. Use this to add revisions alongside existing ones \u2014 no idempotency guard.",
+    "Create a new revision on a Beat. Starts in `draft` state under the PR workflow (draft \u2192 open \u2192 merged) \u2014 NOT the standard Beat Version lifecycle. Transition to `open` when the PR is ready for review; transition to `merged` when the PR is merged. Environment progression (in_staging, ready_for_production, live) is tracked on the parent Beat Version, not the Revision. `beatVersionId` is optional \u2014 omit it for hotfixes, dep bumps, or other operational fixes that don't belong to a planning increment. Orphan Revisions (no BV) must carry their own `description` since there's no BV context to inherit. Use this to add revisions alongside existing ones \u2014 no idempotency guard.",
     {
       beatId: external_exports.string().describe("The beat ID to create the revision on"),
       title: external_exports.string().describe("Title for this revision"),
-      description: external_exports.string().describe("What this revision delivers"),
+      description: external_exports.string().describe("What this revision delivers. Required when beatVersionId is omitted (the description is the audit-trail floor for orphan Revisions)."),
       changeSummary: external_exports.string().describe("Brief summary of the change"),
-      beatVersionId: external_exports.string().min(1).optional().describe("Optional Beat Version ID to associate this revision with"),
+      beatVersionId: external_exports.string().min(1).optional().describe("Beat Version ID to associate this revision with. Omit for hotfixes / orphan changes that don't fit a planning increment."),
       tags: external_exports.array(external_exports.string()).optional().describe("Tags for categorization"),
       priority: external_exports.coerce.number().optional().describe("Priority (lower = higher priority)"),
       estimatedEffort: external_exports.string().optional().describe("Estimated effort (e.g., S, M, L, XL)"),
@@ -25131,12 +25105,13 @@ function registerRevisionLifecycleTools(server, ctx, client) {
         if (!beat) {
           return { content: [{ type: "text", text: `Beat not found: "${beatId}"` }], isError: true };
         }
+        let parentBv;
         if (beatVersionId !== void 0) {
-          const bv = await client.getBeatVersion(beatVersionId);
-          if (!bv) {
+          parentBv = await client.getBeatVersion(beatVersionId);
+          if (!parentBv) {
             return { content: [{ type: "text", text: `Beat Version not found: "${beatVersionId}"` }], isError: true };
           }
-          if (bv.beatId !== beatId || bv.projectId !== beat.projectId) {
+          if (parentBv.beatId !== beatId || parentBv.projectId !== beat.projectId) {
             return { content: [{ type: "text", text: `Beat Version "${beatVersionId}" belongs to a different Beat.` }], isError: true };
           }
         }
@@ -25167,6 +25142,30 @@ function registerRevisionLifecycleTools(server, ctx, client) {
         for (const w of warnings) {
           lines.push("", `**Warning (${w.code}):** ${w.message}`);
         }
+        if (parentBv && !parentBv.targetDropId) {
+          try {
+            const project = await client.getProject(parentBv.projectId);
+            const teamspaceId = project?.teamspaceId;
+            if (teamspaceId) {
+              const draftDrops = await client.listTeamspaceDrops(teamspaceId, { state: "draft" });
+              lines.push("");
+              if (draftDrops.length > 0) {
+                lines.push("\u26A0 **No Drop assigned.** The parent Beat Version has no target Drop. Assign it to track which release this work belongs to.");
+                lines.push("");
+                lines.push("Available draft Drops:");
+                for (const drop of draftDrops) {
+                  lines.push(`  \u2022 ${drop.dropCode} \u2014 ${drop.name} (${drop.dropId})`);
+                }
+                lines.push("");
+                lines.push("Use `update_beat_version` to set `targetDropId`, or call `add_beat_version_to_drop`.");
+              } else {
+                lines.push(`\u26A0 **No Drop assigned and no draft Drops exist in Teamspace \`${teamspaceId}\`.** Create a Drop first with \`create_drop\`, then assign the parent Beat Version to it.`);
+              }
+            }
+          } catch (err) {
+            console.warn("[drop-warning] drop lookup failed for parent Beat Version", beatVersionId, err);
+          }
+        }
         return { content: [{ type: "text", text: lines.join("\n") }] };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -25240,9 +25239,10 @@ function registerRevisionLifecycleTools(server, ctx, client) {
       targetState: external_exports.enum([...LIFECYCLE_STATES, ...PR_LIFECYCLE_STATES]).describe("The target lifecycle state"),
       reason: external_exports.string().optional().describe("Why this transition is being made"),
       skipQualityCheck: external_exports.boolean().optional().describe("Skip the quality check guard (for reconciling already-shipped code)"),
-      reconcile: external_exports.boolean().optional().describe("Walk through all intermediate forward states automatically. Use for already-shipped work that needs state machine catch-up.")
+      reconcile: external_exports.boolean().optional().describe("Walk through all intermediate forward states automatically. Use for already-shipped work that needs state machine catch-up."),
+      mergeCommitSha: external_exports.string().regex(/^[0-9a-f]{7,40}$/).optional().describe("SHA of the merge commit (from the GitHub webhook payload or CI). Stored at the open \u2192 merged transition to enable precise deploy correlation.")
     },
-    async ({ revisionId, targetState, reason, skipQualityCheck, reconcile }) => {
+    async ({ revisionId, targetState, reason, skipQualityCheck, reconcile, mergeCommitSha }) => {
       try {
         const revision = await client.getRevision(revisionId);
         if (!revision) {
@@ -25259,7 +25259,8 @@ function registerRevisionLifecycleTools(server, ctx, client) {
           actor: { type: "human", id: ctx.user.userId, name: ctx.user.name, email: ctx.user.email },
           trigger: "human_action",
           reason,
-          metadata: { source: "mcp", ...skipQualityCheck ? { skipQualityCheck: true } : {} }
+          metadata: { source: "mcp", ...skipQualityCheck ? { skipQualityCheck: true } : {} },
+          ...mergeCommitSha !== void 0 && { mergeCommitSha }
         };
         const result = reconcile ? await client.reconcileRevisionToState(revisionId, targetState, transitionOptions) : await client.transitionRevisionStatus(revisionId, targetState, transitionOptions);
         if (!result.success) {
@@ -25286,6 +25287,11 @@ function registerRevisionLifecycleTools(server, ctx, client) {
 // ../../libs/harmonica-services/src/mcp/tools/session-tools.ts
 var SESSION_STATUSES = ["running", "succeeded", "failed", "timed_out", "cancelled"];
 var SESSION_TYPES = ["planning", "implementation", "triage", "assessment", "composition", "baseline"];
+var SESSION_MESSAGE_MAX_LENGTH = 8e3;
+var STREAM_MAX_EVENTS_DEFAULT = 50;
+var STREAM_MAX_EVENTS_CEILING = 200;
+var STREAM_MAX_WAIT_MS_DEFAULT = 5e3;
+var STREAM_MAX_WAIT_MS_CEILING = 25e3;
 function registerSessionTools(server, ctx, client) {
   server.tool(
     "get_session",
@@ -25370,6 +25376,147 @@ function registerSessionTools(server, ctx, client) {
       };
     }
   );
+  server.tool(
+    "send_session_message",
+    'Send a user-turn message into a running (or held) agent Session. The message is queued for the worker turn loop to inject as the next user input. Returns immediately once queued \u2014 the agent\'s response will appear in the session\'s event stream. Use this to course-correct a running agent without cancelling and restarting (e.g., "switch to React Testing Library", "scope this PR to just X"). Terminal sessions (succeeded, failed, timed_out, cancelled) cannot accept messages \u2014 call this on a `running` or `held` session only.',
+    {
+      sessionId: external_exports.string().min(1).describe("The Session ID (sess-<uuid>) to deliver the message to"),
+      body: external_exports.string().min(1).max(SESSION_MESSAGE_MAX_LENGTH).describe("The user-turn content. Plain text \u2014 no formatting required.")
+    },
+    async ({ sessionId, body }) => {
+      try {
+        const result = await client.sendSessionMessage(sessionId, {
+          body,
+          enqueuedBy: {
+            email: ctx.user.email ?? ctx.user.userId,
+            ...ctx.user.name && { name: ctx.user.name }
+          }
+        });
+        if (result.status === "not_found") {
+          return {
+            content: [{ type: "text", text: `Session not found: ${sessionId}` }],
+            isError: true
+          };
+        }
+        if (result.status === "not_accepting") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Session ${sessionId} cannot accept new messages \u2014 current status: ${result.sessionStatus}. Send messages only to sessions in 'running' or 'held' status.`
+              }
+            ],
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Message queued for session ${sessionId} (messageId: ${result.message.messageId}). It will be delivered as the next user-turn input.`
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to send message: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "resume_session",
+    "Resume a held agent Session (B-205 R2b). Use this when a Session is in the `held` state \u2014 paused by a timeout, harness compaction, or manual hold \u2014 and you want it to continue where it left off without losing the SDK conversation context. The call validates the Session is eligible (still `held`, has the captured SDK session id, has resume budget remaining) and enqueues a resume Task; the worker re-attaches the SDK conversation. Returns the enqueued Task ID \u2014 poll `get_job_status` (or stream the Session via `stream_session_events`) to watch progress. Sessions that are not held (running / terminal / out of budget / origin task missing / lost the atomic claim to a sibling resume call) return a structured `not_resumable` reason \u2014 surface it; don't retry blindly.",
+    {
+      sessionId: external_exports.string().min(1).describe("The Session ID (sess-<uuid>) to resume")
+    },
+    async ({ sessionId }) => {
+      try {
+        const result = await client.resumeSession(sessionId);
+        if (result.status === "not_found") {
+          return {
+            content: [{ type: "text", text: `Session not found: ${sessionId}` }],
+            isError: true
+          };
+        }
+        if (result.status === "not_resumable") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Session ${sessionId} cannot be resumed \u2014 current status: ${result.sessionStatus}, reason: ${result.reason}. Resume requires a session in 'held' state with an SDK session captured and resume budget remaining.`
+              }
+            ],
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Resume queued for session ${sessionId} (taskId: ${result.result.taskId}). Poll \`get_task ${result.result.taskId}\` or stream the session for progress.`
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to resume session: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "stream_session_events",
+    'Long-poll an agent Session\'s event stream. Subscribes to the SSE endpoint and returns a bounded batch of tool/text events plus current status/metrics \u2014 closes N-4E09-2818 by keeping each MCP RPC short while the upstream SSE connection is the real transport. Iterate by passing the returned `nextSinceEventIndex` as `since_event_index` on the next call; stop when `isTerminal: true`. Use this for "watch this session in real time" workflows (agent supervising another agent, live UI tail).',
+    {
+      sessionId: external_exports.string().min(1).describe("The Session ID (sess-<uuid>) to subscribe to"),
+      since_event_index: external_exports.number().int().nonnegative().optional().describe("Resume cursor from the previous batch's `nextSinceEventIndex`. Omit on the first call to receive a `snapshot` record. Server replays events with `index > since_event_index`."),
+      max_events: external_exports.number().int().min(1).max(STREAM_MAX_EVENTS_CEILING).optional().describe(`Cap on records per batch. Default ${STREAM_MAX_EVENTS_DEFAULT}, max ${STREAM_MAX_EVENTS_CEILING}.`),
+      max_wait_ms: external_exports.number().int().min(100).max(STREAM_MAX_WAIT_MS_CEILING).optional().describe(`Cap on batch duration in milliseconds. Default ${STREAM_MAX_WAIT_MS_DEFAULT}, max ${STREAM_MAX_WAIT_MS_CEILING}.`)
+    },
+    async ({ sessionId, since_event_index, max_events, max_wait_ms }) => {
+      try {
+        const result = await client.streamSessionEvents(sessionId, {
+          ...since_event_index !== void 0 && { sinceEventIndex: since_event_index },
+          ...max_events !== void 0 && { maxEvents: max_events },
+          ...max_wait_ms !== void 0 && { maxWaitMs: max_wait_ms }
+        });
+        if (result.status === "not_found") {
+          return {
+            content: [{ type: "text", text: `Session not found: ${sessionId}` }],
+            isError: true
+          };
+        }
+        const header = `Batch: ${result.events.length} record(s) [reason=${result.reason}, isTerminal=${result.isTerminal}${result.nextSinceEventIndex !== void 0 ? `, nextSinceEventIndex=${result.nextSinceEventIndex}` : ""}]`;
+        const lines = result.events.map((e, i) => {
+          const payloadJson = JSON.stringify(e.payload);
+          return `${i + 1}. ${e.kind} ${payloadJson}`;
+        });
+        const body = lines.length > 0 ? `
+${lines.join("\n")}` : "";
+        return { content: [{ type: "text", text: `${header}${body}` }] };
+      } catch (err) {
+        return {
+          content: [
+            { type: "text", text: `Failed to stream session events: ${err instanceof Error ? err.message : String(err)}` }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
   server.tool(
     "cancel_session",
     "Cancel a running agent Session. Idempotent \u2014 calling cancel on a session that is already terminal (succeeded, failed, timed_out, cancelled) returns the existing record unchanged. Use this to stop a runaway agent or free up budget.",
@@ -26003,41 +26150,6 @@ ${JSON.stringify(task.result, null, 2)}
       }
     }
   );
-  server.tool(
-    "implement_work_item",
-    "Trigger an agent session to implement a workItem Note. The agent explores the codebase, writes code, commits, pushes a branch, and creates a PR. Returns a job ID \u2014 use get_job_status to track progress. Requires agentCapabilities.implementation enabled on the project.",
-    {
-      noteId: external_exports.string().describe("The workItem note ID to implement (e.g., N-TF-001)"),
-      projectId: external_exports.string().describe("The project ID")
-    },
-    async ({ noteId, projectId }) => {
-      try {
-        await assertProjectInOrg(client, projectId, ctx.orgId);
-        const task = await client.implementWorkItem(noteId, projectId, {
-          name: ctx.user.name,
-          email: ctx.user.email
-        });
-        return {
-          content: [{
-            type: "text",
-            text: [
-              "Work item implementation session queued.",
-              "",
-              `**Note:** ${noteId}`,
-              `**Task ID:** ${task.taskId}`,
-              `**Status:** ${task.status}`,
-              "",
-              "The agent will explore the codebase, implement the work item, and create a PR.",
-              "Use `get_job_status` with the job ID to check progress and see the result (branch, PR URL, tool count, duration)."
-            ].join("\n")
-          }]
-        };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { content: [{ type: "text", text: `Failed to start implementation: ${message}` }], isError: true };
-      }
-    }
-  );
   server.tool(
     "implement_revision",
     "Trigger an agent session to implement a Revision. The agent reads the Revision spec and beat-level Notes, writes code, commits, pushes a branch named agent/rev-{id}-{title}, and creates a draft PR with the Revision ID pre-populated in the PR body. Returns a job ID \u2014 use get_job_status to track progress. Requires agentCapabilities.implementation enabled on the project.",
@@ -26073,42 +26185,9 @@ ${JSON.stringify(task.result, null, 2)}
       }
     }
   );
-  server.tool(
-    "validate_work_items",
-    "Validate active workItem Notes against the codebase. Checks if work items are already implemented (resolved), no longer relevant (dismissed), or still needed (active). Active items get a solution plan for the implementation agent. Returns a job ID \u2014 use get_job_status to track progress.",
-    {
-      projectId: external_exports.string().describe("The project ID"),
-      noteIds: external_exports.array(external_exports.string()).optional().describe("Specific note IDs to validate. If omitted, validates all active work items.")
-    },
-    async ({ projectId, noteIds }) => {
-      try {
-        await assertProjectInOrg(client, projectId, ctx.orgId);
-        const task = await client.validateWorkItems(projectId, noteIds);
-        return {
-          content: [{
-            type: "text",
-            text: [
-              "Work item validation queued.",
-              "",
-              `**Project:** ${projectId}`,
-              `**Scope:** ${noteIds ? `${noteIds.length} specific items` : "All active work items"}`,
-              `**Task ID:** ${task.taskId}`,
-              `**Status:** ${task.status}`,
-              "",
-              "The validator will grep the codebase for evidence, then classify each item.",
-              "Use `get_job_status` with the job ID to check progress."
-            ].join("\n")
-          }]
-        };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { content: [{ type: "text", text: `Failed to start validation: ${message}` }], isError: true };
-      }
-    }
-  );
   server.tool(
     "plan_revision_batch",
-    "Autonomously generate work items for planning Revisions. If revisionIds are omitted, discovers all planning Revisions with no scoped work items and plans them all. Uses codebase-aware agent sessions when available, LLM-only fallback otherwise. Returns a job ID \u2014 use get_job_status to track progress.",
+    "Autonomously generate an implementation plan for planning Revisions. If revisionIds are omitted, discovers all unplanned planning Revisions and plans them all. Uses codebase-aware agent sessions when available, LLM-only fallback otherwise. Returns a job ID \u2014 use get_job_status to track progress.",
     {
       projectId: external_exports.string().describe("The project ID"),
       revisionIds: external_exports.array(external_exports.string()).optional().describe("Specific revision IDs to plan. If omitted, auto-discovers all unplanned planning revisions.")
@@ -26128,7 +26207,7 @@ ${JSON.stringify(task.result, null, 2)}
               `**Task ID:** ${task.taskId}`,
               `**Status:** ${task.status}`,
               "",
-              "The agent will generate work items for each revision. Revisions stay in planning \u2014 review work items before advancing to building.",
+              "The agent will generate an implementation plan for each revision. Revisions stay in planning \u2014 review the plan before advancing to building.",
               "Use `get_job_status` with the job ID to check progress."
             ].join("\n")
           }]
@@ -26141,7 +26220,7 @@ ${JSON.stringify(task.result, null, 2)}
   );
   server.tool(
     "run_triage",
-    "Run the autonomous triage loop for a project. Analyzes next actions, validates work items against the codebase, auto-executes safe actions (draft_coda, plan_revision_batch, validate_work_items), and escalates items that need human judgment. Requires agentCapabilities.triage enabled on the project. Returns a job ID \u2014 use get_job_status to track progress.",
+    "Run the autonomous triage loop for a project. Analyzes next actions, auto-executes safe actions (draft_coda, plan_revision_batch), and escalates items that need human judgment. Requires agentCapabilities.triage enabled on the project. Returns a job ID \u2014 use get_job_status to track progress.",
     {
       projectId: external_exports.string().describe("The project ID")
     },
@@ -26372,6 +26451,34 @@ function registerAllResources(server, ctx, client) {
 }
 
 // ../../apps/harmonica-mcp-server/src/data-client/http-client.ts
+var STREAM_EVENT_KINDS = /* @__PURE__ */ new Set([
+  "snapshot",
+  "tool_event",
+  "text_event",
+  "metrics_update",
+  "status_change",
+  "terminal"
+]);
+function parseSseBlock(block) {
+  let event = "message";
+  let data = "";
+  for (const line of block.split("\n")) {
+    if (line.startsWith("event: ")) event = line.slice("event: ".length).trim();
+    else if (line.startsWith("data: ")) data += (data ? "\n" : "") + line.slice("data: ".length);
+  }
+  if (!data) return void 0;
+  return { event, data };
+}
+function toStreamRecord(event, dataStr) {
+  if (!STREAM_EVENT_KINDS.has(event)) return void 0;
+  let payload;
+  try {
+    payload = JSON.parse(dataStr);
+  } catch {
+    return void 0;
+  }
+  return { kind: event, payload };
+}
 var ApiError = class extends Error {
   constructor(status, body) {
     super(`API ${status}: ${body}`);
@@ -26709,26 +26816,6 @@ function createHttpClient(config2) {
     getNextNoteId: async (projectCode) => {
       return `N-${projectCode}-${Date.now()}`;
     },
-    saveTasksAsWorkItemNotes: async (projectId, beatId, tasks) => {
-      const results = await Promise.all(
-        tasks.map(
-          (task) => request("POST", `/api/projects/${encodeURIComponent(projectId)}/notes`, {
-            noteType: "workItem",
-            content: `**${task.title}** \u2014 ${task.description}`,
-            beatId,
-            workItemMeta: {
-              category: task.category,
-              complexity: task.complexity,
-              scope: task.scope,
-              estimatedHoursRange: task.estimatedHoursRange,
-              acceptanceCheck: task.acceptanceCheck,
-              whyOutOfScope: task.whyOutOfScope
-            }
-          })
-        )
-      );
-      return results.map((r) => r?.note ?? r);
-    },
     reassignNote: async (noteId, targetBeatId, reason, _actorId, targetRevisionId) => {
       const note = await request("GET", `/api/notes/${encodeURIComponent(noteId)}`);
       if (!note?.note) return void 0;
@@ -26809,7 +26896,8 @@ function createHttpClient(config2) {
             actorName: options.actor.name,
             trigger: options.trigger,
             reason: options.reason,
-            metadata: options.metadata
+            metadata: options.metadata,
+            ...options.mergeCommitSha !== void 0 && { mergeCommitSha: options.mergeCommitSha }
           }
         );
         if (raw === void 0) {
@@ -26878,6 +26966,164 @@ function createHttpClient(config2) {
       return result ?? [];
     },
     cancelSession: (sessionId, options) => request("POST", `/api/sessions/${encodeURIComponent(sessionId)}/cancel`, { reason: options.reason }),
+    sendSessionMessage: async (sessionId, options) => {
+      try {
+        const result = await request("POST", `/api/sessions/${encodeURIComponent(sessionId)}/messages`, {
+          body: options.body,
+          enqueuedBy: options.enqueuedBy
+        });
+        if (!result) return { status: "not_found" };
+        return { status: "enqueued", message: result };
+      } catch (err) {
+        if (err instanceof ApiError && err.status === 409) {
+          const parsed = safeParseErrorBody(err.body);
+          if (parsed?.sessionStatus) {
+            return { status: "not_accepting", sessionStatus: parsed.sessionStatus };
+          }
+        }
+        throw err;
+      }
+    },
+    resumeSession: async (sessionId) => {
+      try {
+        const result = await request("POST", `/api/sessions/${encodeURIComponent(sessionId)}/resume`);
+        if (!result) return { status: "not_found" };
+        return { status: "resumed", result };
+      } catch (err) {
+        if (err instanceof ApiError && err.status === 409) {
+          const parsed = safeParseErrorBody(err.body);
+          if (parsed?.code === "SESSION_NOT_RESUMABLE") {
+            return {
+              status: "not_resumable",
+              sessionStatus: parsed.sessionStatus ?? "held",
+              reason: parsed.reason ?? "not_held"
+            };
+          }
+        }
+        throw err;
+      }
+    },
+    streamSessionEvents: async (sessionId, options) => {
+      const maxEvents = Math.min(Math.max(options?.maxEvents ?? 50, 1), 200);
+      const maxWaitMs = Math.min(Math.max(options?.maxWaitMs ?? 5e3, 100), 25e3);
+      const params = new URLSearchParams();
+      if (options?.sinceEventIndex !== void 0) {
+        params.set("since_event_index", String(options.sinceEventIndex));
+      }
+      const qs = params.toString() ? `?${params.toString()}` : "";
+      const url2 = `${config2.apiBaseUrl}/api/sessions/${encodeURIComponent(sessionId)}/events${qs}`;
+      const controller = new AbortController();
+      const deadlineTimer = setTimeout(() => controller.abort(), maxWaitMs);
+      let res;
+      try {
+        res = await fetch(url2, {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${config2.apiKey}`,
+            Accept: "text/event-stream"
+          },
+          signal: controller.signal
+        });
+      } catch (err) {
+        clearTimeout(deadlineTimer);
+        if (err.name === "AbortError" && controller.signal.aborted) {
+          return { status: "ok", events: [], isTerminal: false, reason: "max_wait", ...options?.sinceEventIndex !== void 0 && { nextSinceEventIndex: options.sinceEventIndex } };
+        }
+        throw err;
+      }
+      if (res.status === 404) {
+        clearTimeout(deadlineTimer);
+        return { status: "not_found" };
+      }
+      if (!res.ok) {
+        clearTimeout(deadlineTimer);
+        const text = await res.text();
+        throw new ApiError(res.status, text);
+      }
+      if (!res.body) {
+        clearTimeout(deadlineTimer);
+        return { status: "ok", events: [], isTerminal: false, reason: "max_wait", ...options?.sinceEventIndex !== void 0 && { nextSinceEventIndex: options.sinceEventIndex } };
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder("utf-8");
+      let buffer = "";
+      const events = [];
+      let nextSinceEventIndex = options?.sinceEventIndex;
+      let isTerminal2 = false;
+      let reason = "max_wait";
+      const deadline = Date.now() + maxWaitMs;
+      const TIMEOUT = Symbol("stream-timeout");
+      try {
+        outer: while (true) {
+          const remaining = deadline - Date.now();
+          if (remaining <= 0) {
+            reason = "max_wait";
+            break outer;
+          }
+          let timerHandle;
+          const raced = await Promise.race([
+            reader.read(),
+            new Promise((resolve) => {
+              timerHandle = setTimeout(() => resolve(TIMEOUT), remaining);
+            })
+          ]);
+          if (timerHandle) clearTimeout(timerHandle);
+          if (raced === TIMEOUT) {
+            reason = "max_wait";
+            break outer;
+          }
+          const { done, value } = raced;
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          let sepIdx;
+          while ((sepIdx = buffer.indexOf("\n\n")) !== -1) {
+            const block = buffer.slice(0, sepIdx);
+            buffer = buffer.slice(sepIdx + 2);
+            const parsed = parseSseBlock(block);
+            if (!parsed) continue;
+            if (parsed.event === "heartbeat") continue;
+            const record2 = toStreamRecord(parsed.event, parsed.data);
+            if (!record2) continue;
+            events.push(record2);
+            if (record2.kind === "tool_event" || record2.kind === "text_event") {
+              const idx = record2.payload.index;
+              if (typeof idx === "number" && (nextSinceEventIndex === void 0 || idx > nextSinceEventIndex)) {
+                nextSinceEventIndex = idx;
+              }
+            }
+            if (record2.kind === "terminal") {
+              isTerminal2 = true;
+              reason = "terminal";
+              break outer;
+            }
+            if (events.length >= maxEvents) {
+              reason = "max_events";
+              break outer;
+            }
+          }
+        }
+      } catch (err) {
+        if (!controller.signal.aborted) throw err;
+        reason = "max_wait";
+      } finally {
+        clearTimeout(deadlineTimer);
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        try {
+          controller.abort();
+        } catch {
+        }
+      }
+      return {
+        status: "ok",
+        events,
+        isTerminal: isTerminal2,
+        reason,
+        ...nextSinceEventIndex !== void 0 && { nextSinceEventIndex }
+      };
+    },
     // Tasks
     getTask: async (taskId) => {
       return request("GET", `/api/tasks/${encodeURIComponent(taskId)}`);
@@ -27016,15 +27262,6 @@ function createHttpClient(config2) {
       return pollTaskResult(enqueued.taskId);
     },
     // Agent sessions
-    implementWorkItem: async (noteId, projectId, triggeredBy) => {
-      const result = await request(
-        "POST",
-        `/api/projects/${encodeURIComponent(projectId)}/notes/${encodeURIComponent(noteId)}/implement`,
-        triggeredBy ? { triggeredBy } : {}
-      );
-      if (!result?.taskId) throw new Error("Implementation enqueue failed: no taskId returned");
-      return { taskId: result.taskId, taskType: "work_item_implementation", status: result.status ?? "pending", projectId, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
-    },
     implementRevision: async (revisionId, projectId, triggeredBy) => {
       const result = await request(
         "POST",
@@ -27034,15 +27271,6 @@ function createHttpClient(config2) {
       if (!result?.taskId) throw new Error("Revision implementation enqueue failed: no taskId returned");
       return { taskId: result.taskId, taskType: "revision_implementation", status: result.status ?? "pending", projectId, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
     },
-    validateWorkItems: async (projectId, noteIds) => {
-      const result = await request(
-        "POST",
-        `/api/projects/${encodeURIComponent(projectId)}/work-items/validate`,
-        noteIds ? { noteIds } : {}
-      );
-      if (!result?.taskId) throw new Error("Validation enqueue failed: no taskId returned");
-      return { taskId: result.taskId, taskType: "work_item_validation", status: result.status ?? "pending", projectId, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
-    },
     planRevisionBatch: async (projectId, revisionIds) => {
       const result = await request(
         "POST",
@@ -27222,6 +27450,14 @@ function createHttpClient(config2) {
       );
       return res.checks;
     },
+    listDropChecks: async (dropId, _projectId, checkType) => {
+      const qs = checkType ? `?type=${encodeURIComponent(checkType)}` : "";
+      const res = await request(
+        "GET",
+        `/api/drops/${encodeURIComponent(dropId)}/checks${qs}`
+      );
+      return res.checks;
+    },
     addCheckFeedback: async (checkId, feedback) => {
       const res = await request(
         "POST",
@@ -27356,7 +27592,11 @@ function createHttpClient(config2) {
         if (res === void 0) {
           return { success: false, error: { code: "BEAT_VERSION_NOT_FOUND", message: "Beat version not found" } };
         }
-        return { success: true };
+        return {
+          success: true,
+          ...res.fanOutCount !== void 0 && { fanOutCount: res.fanOutCount },
+          ...res.fanOutWarning && { fanOutWarning: res.fanOutWarning }
+        };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return { success: false, error: { code: "TRANSITION_FAILED", message } };
@@ -27457,7 +27697,7 @@ function loadConfig() {
   };
 }
 async function main() {
-  console.error(`[harmonica-mcp] v${"0.29.0"} starting\u2026`);
+  console.error(`[harmonica-mcp] v${"0.30.0"} starting\u2026`);
   const config2 = loadConfig();
   const client = createHttpClient({
     apiBaseUrl: config2.apiBaseUrl,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codazen/harmonica-mcp",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "MCP server for Harmonica — connect Claude to your Harmonica projects",
   "license": "MIT",
   "bin": {