@codazen/harmonica-mcp 0.23.0 → 0.25.0

package/dist/index.js

@@ -22214,6 +22214,127 @@ function formatNoteDetail(note) {
   return parts.join("\n");
 }
 
+// ../../libs/harmonica-services/src/mcp/formatters/session-formatter.ts
+var TYPE_LABELS2 = {
+  planning: "Planning",
+  implementation: "Implementation",
+  triage: "Triage",
+  assessment: "Assessment",
+  composition: "Composition",
+  baseline: "Baseline"
+};
+var STATUS_LABELS = {
+  running: "Running",
+  succeeded: "Succeeded",
+  failed: "Failed",
+  timed_out: "Timed Out",
+  cancelled: "Cancelled"
+};
+var EVENT_TAIL_LIMIT = 10;
+function formatSessionSummary(session) {
+  const type = TYPE_LABELS2[session.sessionType] ?? session.sessionType;
+  const status = STATUS_LABELS[session.status] ?? session.status;
+  const duration3 = session.endedAt ? ` \xB7 ${formatRelativeWindow(session.startedAt, session.endedAt)}` : "";
+  const scope = formatScopeSuffix(session);
+  const actor = session.actorPersona ? ` \xB7 ${session.actorPersona}` : "";
+  return `- **${type}** (${session.sessionId}) [${status}]${actor}${duration3}${scope}`;
+}
+function formatSessionList(sessions, scopeLabel) {
+  if (sessions.length === 0) {
+    return `No sessions found for ${scopeLabel}.`;
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const bucket = grouped.get(s.status) ?? [];
+    bucket.push(s);
+    grouped.set(s.status, bucket);
+  }
+  const parts = [`**${sessions.length} session${sessions.length === 1 ? "" : "s"}** (${scopeLabel})`, ""];
+  for (const [status, items] of grouped) {
+    parts.push(`### ${STATUS_LABELS[status] ?? status} (${items.length})`);
+    for (const item of items) {
+      parts.push(formatSessionSummary(item));
+    }
+    parts.push("");
+  }
+  return parts.join("\n").trimEnd();
+}
+function formatSessionDetail(session) {
+  const type = TYPE_LABELS2[session.sessionType] ?? session.sessionType;
+  const status = STATUS_LABELS[session.status] ?? session.status;
+  const parts = [
+    `# Session: ${session.sessionId}`,
+    "",
+    `**Type:** ${type}`,
+    `**Status:** ${status}`,
+    `**Project:** ${session.projectId}`,
+    `**Actor:** ${session.actor.agentPersona}${session.actor.agentRole ? ` (${session.actor.agentRole})` : ""}`
+  ];
+  if (session.actor.initiator) {
+    const i = session.actor.initiator;
+    parts.push(`**Initiated by:** ${i.type}/${i.id}${i.name ? ` (${i.name})` : ""}`);
+  }
+  if (session.beatId) parts.push(`**Beat:** ${session.beatId}`);
+  if (session.beatVersionId) parts.push(`**Beat Version:** ${session.beatVersionId}`);
+  if (session.revisionId) parts.push(`**Revision:** ${session.revisionId}`);
+  if (session.triggerSource) parts.push(`**Trigger:** ${session.triggerSource}`);
+  parts.push("");
+  parts.push(`**Started:** ${session.startedAt}`);
+  if (session.endedAt) parts.push(`**Ended:** ${session.endedAt}`);
+  if (session.metrics) {
+    parts.push("", "### Metrics");
+    const m = session.metrics;
+    if (m.durationMs != null) parts.push(`- Duration: ${formatDurationMs(m.durationMs)}`);
+    if (m.toolCallCount != null) parts.push(`- Tool calls: ${m.toolCallCount}`);
+    if (m.inputTokens != null) parts.push(`- Input tokens: ${m.inputTokens}`);
+    if (m.outputTokens != null) parts.push(`- Output tokens: ${m.outputTokens}`);
+    if (m.totalTokens != null) parts.push(`- Total tokens: ${m.totalTokens}`);
+    if (m.estimatedCostUsd != null) parts.push(`- Est. cost: $${m.estimatedCostUsd.toFixed(4)}`);
+  }
+  if (session.errorMessage) {
+    parts.push("", "### Error");
+    parts.push(session.errorMessage);
+  }
+  const toolEvents = session.toolEvents ?? [];
+  if (toolEvents.length > 0) {
+    parts.push("", `### Tool Events (showing last ${Math.min(toolEvents.length, EVENT_TAIL_LIMIT)} of ${toolEvents.length})`);
+    for (const ev of toolEvents.slice(-EVENT_TAIL_LIMIT)) {
+      const dur = ev.durationMs != null ? ` (${ev.durationMs}ms)` : "";
+      const result = ev.resultStatus ? ` \u2014 ${ev.resultStatus}` : "";
+      parts.push(`- [${ev.index}] ${ev.toolName}${result}${dur}`);
+    }
+  }
+  const textEvents = session.textEvents ?? [];
+  if (textEvents.length > 0) {
+    parts.push("", `### Text Events (${textEvents.length})`);
+    for (const ev of textEvents.slice(-EVENT_TAIL_LIMIT)) {
+      const preview = ev.content.length > 160 ? `${ev.content.slice(0, 160)}\u2026` : ev.content;
+      parts.push(`- [${ev.index}] ${preview}`);
+    }
+  }
+  parts.push("", `_Created: ${session.createdAt}_`);
+  return parts.join("\n");
+}
+function formatScopeSuffix(session) {
+  const parts = [];
+  if ("beatId" in session && session.beatId) parts.push(`Beat: ${session.beatId}`);
+  if ("revisionId" in session && session.revisionId) parts.push(`Rev: ${session.revisionId}`);
+  return parts.length > 0 ? ` [${parts.join(" \xB7 ")}]` : "";
+}
+function formatRelativeWindow(startedAt, endedAt) {
+  const ms = new Date(endedAt).getTime() - new Date(startedAt).getTime();
+  if (!Number.isFinite(ms) || ms < 0) return "";
+  return formatDurationMs(ms);
+}
+function formatDurationMs(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remSec = seconds % 60;
+  return remSec === 0 ? `${minutes}m` : `${minutes}m ${remSec}s`;
+}
+
 // ../../libs/harmonica-services/src/mcp/tools/beat-tools.ts
 function registerBeatTools(server, ctx, client) {
   server.tool(
@@ -24696,24 +24817,35 @@ function registerRevisionLifecycleTools(server, ctx, client) {
       title: external_exports.string().describe("Title for this revision"),
       description: external_exports.string().describe("What this revision delivers"),
       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"),
       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)"),
       humanAssignee: humanAssigneeSchema.optional().describe('Human assignee (e.g. { email: "mmerchant@codazen.com", name: "Mike Merchant" })'),
       agentAssignee: agentAssigneeSchema.optional().describe('Agent assignee (e.g. { agentId: "maya", name: "Maya" })')
     },
-    async ({ beatId, title, description, changeSummary, tags, priority, estimatedEffort, humanAssignee, agentAssignee }) => {
+    async ({ beatId, title, description, changeSummary, beatVersionId, tags, priority, estimatedEffort, humanAssignee, agentAssignee }) => {
       try {
         await assertBeatInOrg(client, beatId, ctx.orgId);
         const beat = await client.getBeat(beatId);
         if (!beat) {
           return { content: [{ type: "text", text: `Beat not found: "${beatId}"` }], isError: true };
         }
+        if (beatVersionId !== void 0) {
+          const bv = await client.getBeatVersion(beatVersionId);
+          if (!bv) {
+            return { content: [{ type: "text", text: `Beat Version not found: "${beatVersionId}"` }], isError: true };
+          }
+          if (bv.beatId !== beatId || bv.projectId !== beat.projectId) {
+            return { content: [{ type: "text", text: `Beat Version "${beatVersionId}" belongs to a different Beat.` }], isError: true };
+          }
+        }
         const { revision, warnings } = await client.createRevision(beat.projectId, beatId, {
           title,
           description,
           changeSummary,
           changeImportance: "moderate",
+          beatVersionId,
           tags,
           priority,
           estimatedEffort,
@@ -24750,23 +24882,34 @@ function registerRevisionLifecycleTools(server, ctx, client) {
       changeSummary: external_exports.string().describe("Why this change is being made (recorded in audit trail)"),
       title: external_exports.string().optional().describe("New title"),
       description: external_exports.string().optional().describe("New description (what this revision delivers)"),
+      beatVersionId: external_exports.string().min(1).nullable().optional().describe("Beat Version ID to associate \u2014 set null to clear"),
       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("Effort estimate (e.g., S, M, L, XL)"),
       humanAssignee: humanAssigneeSchema.nullable().optional().describe("Human assignee \u2014 set null to clear"),
       agentAssignee: agentAssigneeSchema.nullable().optional().describe("Agent assignee \u2014 set null to clear")
     },
-    async ({ revisionId, changeSummary, ...changes }) => {
+    async ({ revisionId, changeSummary, beatVersionId, ...changes }) => {
       try {
         const revision = await client.getRevision(revisionId);
         if (!revision) {
           return { content: [{ type: "text", text: `Revision not found: "${revisionId}"` }], isError: true };
         }
         await assertBeatInOrg(client, revision.beatId, ctx.orgId);
+        if (typeof beatVersionId === "string") {
+          const bv = await client.getBeatVersion(beatVersionId);
+          if (!bv) {
+            return { content: [{ type: "text", text: `Beat Version not found: "${beatVersionId}"` }], isError: true };
+          }
+          if (bv.beatId !== revision.beatId || bv.projectId !== revision.projectId) {
+            return { content: [{ type: "text", text: `Beat Version "${beatVersionId}" belongs to a different Beat.` }], isError: true };
+          }
+        }
         const updates = { changeSummary };
         for (const [k, v] of Object.entries(changes)) {
           if (v !== void 0) updates[k] = v;
         }
+        if (beatVersionId !== void 0) updates.beatVersionId = beatVersionId;
         if (Object.keys(updates).length <= 1) {
           return { content: [{ type: "text", text: "No fields provided to update." }], isError: true };
         }
@@ -24840,11 +24983,141 @@ 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"];
+function registerSessionTools(server, ctx, client) {
+  server.tool(
+    "get_session",
+    'Get full details of an agent Session by ID \u2014 type, status, actor, scoping links (beat/revision), metrics, structured result, and the recent tool/text events. Use this when the user asks "what did that session do?" or to inspect a specific agent run.',
+    {
+      sessionId: external_exports.string().min(1).describe("The Session ID (sess-<uuid>)")
+    },
+    async ({ sessionId }) => {
+      const session = await client.getSession(sessionId);
+      if (!session) {
+        return {
+          content: [{ type: "text", text: `Session not found: ${sessionId}` }],
+          isError: true
+        };
+      }
+      return { content: [{ type: "text", text: formatSessionDetail(session) }] };
+    }
+  );
+  server.tool(
+    "list_project_sessions",
+    'List agent Sessions in a project, optionally filtered by status, type, or whether terminal sessions are included. Use this to answer "show me sessions in this project" or to find recent runs across all beats.',
+    {
+      projectId: external_exports.string().min(1).describe("The project ID"),
+      status: external_exports.enum(SESSION_STATUSES).optional().describe("Filter by status: running, succeeded, failed, timed_out, cancelled"),
+      sessionType: external_exports.enum(SESSION_TYPES).optional().describe("Filter by session type"),
+      includeTerminal: external_exports.boolean().optional().describe("Include terminal sessions (succeeded/failed/timed_out/cancelled). Default false.")
+    },
+    async ({ projectId, status, sessionType, includeTerminal }) => {
+      const sessions = await client.listProjectSessions(projectId, {
+        status,
+        sessionType,
+        includeTerminal
+      });
+      return {
+        content: [
+          { type: "text", text: formatSessionList(sessions, `project ${projectId}`) }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list_beat_sessions",
+    'List agent Sessions scoped to a Beat. Use this to see every agent run that touched a specific capability \u2014 useful for "what work has been done on this beat?" investigations.',
+    {
+      beatId: external_exports.string().min(1).describe("The Beat ID (e.g., PROJ-B-001)"),
+      status: external_exports.enum(SESSION_STATUSES).optional().describe("Filter by status"),
+      sessionType: external_exports.enum(SESSION_TYPES).optional().describe("Filter by session type"),
+      includeTerminal: external_exports.boolean().optional().describe("Include terminal sessions. Default false.")
+    },
+    async ({ beatId, status, sessionType, includeTerminal }) => {
+      const sessions = await client.listBeatSessions(beatId, {
+        status,
+        sessionType,
+        includeTerminal
+      });
+      return {
+        content: [
+          { type: "text", text: formatSessionList(sessions, `beat ${beatId}`) }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list_revision_sessions",
+    'List agent Sessions scoped to a specific Revision. Use this when a user asks "what did the agent do on this PR/revision?" \u2014 typically planning and implementation sessions.',
+    {
+      revisionId: external_exports.string().min(1).describe("The Revision ID (rev-<uuid>)"),
+      status: external_exports.enum(SESSION_STATUSES).optional().describe("Filter by status"),
+      sessionType: external_exports.enum(SESSION_TYPES).optional().describe("Filter by session type"),
+      includeTerminal: external_exports.boolean().optional().describe("Include terminal sessions. Default false.")
+    },
+    async ({ revisionId, status, sessionType, includeTerminal }) => {
+      const sessions = await client.listRevisionSessions(revisionId, {
+        status,
+        sessionType,
+        includeTerminal
+      });
+      return {
+        content: [
+          { type: "text", text: formatSessionList(sessions, `revision ${revisionId}`) }
+        ]
+      };
+    }
+  );
+  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.",
+    {
+      sessionId: external_exports.string().min(1).describe("The Session ID to cancel"),
+      reason: external_exports.string().optional().describe("Why the session is being cancelled (audit trail)")
+    },
+    async ({ sessionId, reason }) => {
+      try {
+        const session = await client.cancelSession(sessionId, {
+          actor: {
+            type: "human",
+            id: ctx.user.userId,
+            ...ctx.user.name && { name: ctx.user.name },
+            ...ctx.user.email && { email: ctx.user.email }
+          },
+          reason
+        });
+        if (!session) {
+          return {
+            content: [{ type: "text", text: `Session not found: ${sessionId}` }],
+            isError: true
+          };
+        }
+        return {
+          content: [{ type: "text", text: formatSessionDetail(session) }]
+        };
+      } catch (err) {
+        return {
+          content: [
+            { type: "text", text: `Failed to cancel session: ${err instanceof Error ? err.message : String(err)}` }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
 // ../../libs/harmonica-services/src/mcp/tools/snapshot-tools.ts
 var import_promises = require("node:fs/promises");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
-var SNAPSHOT_VERSION = 1;
+
+// ../../libs/harmonica-services/src/project-snapshot.constants.ts
+var SNAPSHOT_VERSION = 2;
+
+// ../../libs/harmonica-services/src/mcp/tools/snapshot-tools.ts
 function registerSnapshotTools(server, ctx, client) {
   server.tool(
     "export_project_snapshot",
@@ -24910,37 +25183,29 @@ function registerSnapshotTools(server, ctx, client) {
           isError: true
         };
       }
+      const trimmed = snapshotInput.trim();
+      const importOptions = { targetOrgId: ctx.orgId, targetUserId: ctx.user.userId };
+      if (trimmed.startsWith("https://")) {
+        if (isPrivateHost(trimmed)) {
+          throw new Error("Snapshot URL must point to a public host \u2014 private, link-local, and loopback addresses are not permitted.");
+        }
+        const result2 = await client.importProjectSnapshotFromUrl(trimmed, importOptions);
+        return { content: [{ type: "text", text: formatImportSummary(result2) }] };
+      }
+      if (trimmed.startsWith("http://")) {
+        throw new Error("Snapshot URL must use https:// \u2014 http:// is not permitted.");
+      }
       const snapshotJson = await resolveSnapshotInput(snapshotInput);
       let parsed;
       try {
         parsed = JSON.parse(snapshotJson);
       } catch {
-        const urlHint = snapshotInput.trim().startsWith("https://") ? ` fetched from ${snapshotInput.trim().split("?")[0]}` : "";
-        throw new Error(`Snapshot is not valid JSON${urlHint}. The URL may have returned an error page instead of snapshot data.`);
+        throw new Error("Snapshot is not valid JSON. The content may be corrupted.");
       }
-      assertSnapshotShape(parsed, snapshotInput.trim().startsWith("https://") ? ` fetched from ${snapshotInput.trim().split("?")[0]}` : "");
+      assertSnapshotShape(parsed, "");
       const normalized = normalizeSnapshot(parsed);
-      const result = await client.importProjectSnapshot(normalized, {
-        targetOrgId: ctx.orgId,
-        targetUserId: ctx.user.userId
-      });
-      const summary = [
-        `Imported project: ${result.projectId}`,
-        `  Beats: ${result.counts.beats}`,
-        `  Proposals: ${result.counts.proposals}`,
-        `  Revisions: ${result.counts.revisions}`,
-        `  Activities: ${result.counts.activities}`,
-        `  Questions: ${result.counts.questions}`,
-        `  Notes: ${result.counts.notes}`,
-        `  Tasks: ${result.counts.tasks}`,
-        `  Submissions: ${result.counts.submissions}`,
-        `  PromptLogs: ${result.counts.promptLogs}`
-      ];
-      if (result.errors.length > 0) {
-        summary.push("", `Errors (${result.errors.length}):`);
-        result.errors.forEach((e) => summary.push(`  - ${e}`));
-      }
-      return { content: [{ type: "text", text: summary.join("\n") }] };
+      const result = await client.importProjectSnapshot(normalized, importOptions);
+      return { content: [{ type: "text", text: formatImportSummary(result) }] };
     }
   );
 }
@@ -24964,32 +25229,44 @@ function normalizeSnapshot(raw) {
     taskIndex: raw.taskIndex ?? [],
     submissions: raw.submissions ?? [],
     submissionIndex: raw.submissionIndex ?? [],
-    promptLogs: raw.promptLogs ?? []
+    promptLogs: raw.promptLogs ?? [],
+    beatVersions: raw.beatVersions ?? [],
+    beatBeatVersionIndex: raw.beatBeatVersionIndex ?? [],
+    projectBeatVersionIndex: raw.projectBeatVersionIndex ?? [],
+    beatVersionDropAssignments: raw.beatVersionDropAssignments ?? [],
+    drops: raw.drops ?? [],
+    teamspaceDropIndex: raw.teamspaceDropIndex ?? [],
+    deliverables: raw.deliverables ?? [],
+    teamspaceDeliverableIndex: raw.teamspaceDeliverableIndex ?? [],
+    projectDeliverableIndex: raw.projectDeliverableIndex ?? []
   };
 }
 async function resolveSnapshotInput(input) {
   const trimmed = input.trim();
-  if (trimmed.startsWith("https://")) {
-    if (isPrivateHost(trimmed)) {
-      throw new Error("Snapshot URL must point to a public host \u2014 private, link-local, and loopback addresses are not permitted.");
-    }
-    let res;
-    try {
-      res = await fetch(trimmed, { redirect: "error", signal: AbortSignal.timeout(3e4) });
-    } catch (err) {
-      throw new Error(`Failed to fetch snapshot URL: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    if (!res.ok) throw new Error(`Failed to fetch snapshot from URL: ${res.status}`);
-    return res.text();
-  }
-  if (trimmed.startsWith("http://")) {
-    throw new Error("Snapshot URL must use https:// \u2014 http:// is not permitted.");
-  }
   if (trimmed.startsWith("/") || trimmed.startsWith("~")) {
     return (0, import_promises.readFile)(trimmed, "utf-8");
   }
   return trimmed;
 }
+function formatImportSummary(result) {
+  const lines = [
+    `Imported project: ${result.projectId}`,
+    `  Beats: ${result.counts.beats}`,
+    `  Proposals: ${result.counts.proposals}`,
+    `  Revisions: ${result.counts.revisions}`,
+    `  Activities: ${result.counts.activities}`,
+    `  Questions: ${result.counts.questions}`,
+    `  Notes: ${result.counts.notes}`,
+    `  Tasks: ${result.counts.tasks}`,
+    `  Submissions: ${result.counts.submissions}`,
+    `  PromptLogs: ${result.counts.promptLogs}`
+  ];
+  if (result.errors.length > 0) {
+    lines.push("", `Errors (${result.errors.length}):`);
+    result.errors.forEach((e) => lines.push(`  - ${e}`));
+  }
+  return lines.join("\n");
+}
 function isPrivateHost(url) {
   let hostname2;
   try {
@@ -25650,6 +25927,7 @@ function registerAllTools(server, ctx, client) {
   registerTeamspaceTools(server, ctx, client);
   registerDeliverableTools(server, ctx, client);
   registerDropTools(server, ctx, client);
+  registerSessionTools(server, ctx, client);
   registerOnboardingTools(server, ctx, client);
 }
 
@@ -26185,6 +26463,40 @@ function createHttpClient(config2) {
       }
       return { success: true };
     },
+    // Sessions (B-150). All three list methods point at the same flat
+    // `GET /api/sessions?<scope>=` endpoint — the DataClient interface
+    // surfaces three methods because the data layer has three DDB index
+    // partitions, but the REST surface is unified per the project-level
+    // "avoid nested/duplicate routes" guidance.
+    getSession: (sessionId) => request("GET", `/api/sessions/${encodeURIComponent(sessionId)}`),
+    listProjectSessions: async (projectId, options) => {
+      const params = new URLSearchParams();
+      params.set("projectId", projectId);
+      if (options?.status) params.set("status", options.status);
+      if (options?.sessionType) params.set("sessionType", options.sessionType);
+      if (options?.includeTerminal) params.set("includeTerminal", "true");
+      const result = await request("GET", `/api/sessions?${params.toString()}`);
+      return result ?? [];
+    },
+    listBeatSessions: async (beatId, options) => {
+      const params = new URLSearchParams();
+      params.set("beatId", beatId);
+      if (options?.status) params.set("status", options.status);
+      if (options?.sessionType) params.set("sessionType", options.sessionType);
+      if (options?.includeTerminal) params.set("includeTerminal", "true");
+      const result = await request("GET", `/api/sessions?${params.toString()}`);
+      return result ?? [];
+    },
+    listRevisionSessions: async (revisionId, options) => {
+      const params = new URLSearchParams();
+      params.set("revisionId", revisionId);
+      if (options?.status) params.set("status", options.status);
+      if (options?.sessionType) params.set("sessionType", options.sessionType);
+      if (options?.includeTerminal) params.set("includeTerminal", "true");
+      const result = await request("GET", `/api/sessions?${params.toString()}`);
+      return result ?? [];
+    },
+    cancelSession: (sessionId, options) => request("POST", `/api/sessions/${encodeURIComponent(sessionId)}/cancel`, { reason: options.reason }),
     // Tasks
     getTask: async (taskId) => {
       return request("GET", `/api/tasks/${encodeURIComponent(taskId)}`);
@@ -26418,6 +26730,7 @@ function createHttpClient(config2) {
       return download;
     },
     importProjectSnapshot: (snapshot, options) => request("POST", "/api/projects/import", { ...snapshot, importOptions: options }, LONG_RUNNING_TIMEOUT_MS),
+    importProjectSnapshotFromUrl: (url2, options) => request("POST", "/api/projects/import", { snapshotUrl: url2, importOptions: options }, LONG_RUNNING_TIMEOUT_MS),
     // Embedding similarity
     embedProjectEntities: (projectId) => request("POST", `/api/projects/${encodeURIComponent(projectId)}/embeddings/generate`),
     findSimilarNotes: async (noteId, projectId, options) => {
@@ -26725,7 +27038,7 @@ function loadConfig() {
   };
 }
 async function main() {
-  console.error(`[harmonica-mcp] v${"0.23.0"} starting\u2026`);
+  console.error(`[harmonica-mcp] v${"0.25.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.23.0",
+  "version": "0.25.0",
   "description": "MCP server for Harmonica — connect Claude to your Harmonica projects",
   "license": "MIT",
   "bin": {