@ateam-ai/mcp 0.4.52 → 0.4.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ateam-ai/mcp",
-  "version": "0.4.52",
+  "version": "0.4.57",
   "mcpName": "io.github.ariekogan/ateam-mcp",
   "description": "A-Team MCP Server — build, validate, and deploy multi-agent solutions from any AI environment",
   "type": "module",

package/src/tools.js

@@ -1017,6 +1017,59 @@ export const tools = [
     },
   },
 
+  {
+    name: "ateam_log_lesson",
+    core: true,
+    description:
+      "Record ONE lesson this run learned, so the NEXT run does not relearn it. " +
+      "A building agent starts every run empty — it does not know which tool " +
+      "misled the last run or the workaround that got past it. Log a lesson the " +
+      "moment a tool misleads you AND you find a way through.\n\n" +
+      "APPEND-ONLY. You cannot edit or delete earlier lessons, and you do not " +
+      "supply the timestamp, job or actor — the server stamps those.\n\n" +
+      "LOG ONLY WHAT YOU OBSERVED. Quote the error VERBATIM; never paraphrase it " +
+      "and never write a theory about platform internals. A wrong lesson is worse " +
+      "than no lesson, because the next run cannot check it and will act on it.\n\n" +
+      "Use kind='misleading_success' when a call REPORTED success while the thing " +
+      "you wanted did not happen — that class is the most expensive to rediscover " +
+      "and it is invisible to a failures-only log.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        solution_id: { type: "string", description: "The solution this lesson belongs to" },
+        tool: { type: "string", description: "The tool that misled you, e.g. \"ateam_build_and_run\"" },
+        error: { type: "string", description: "The VERBATIM error or failed_steps fragment. Not a paraphrase." },
+        workaround: { type: "string", description: "What you did instead (optional)" },
+        worked: { type: "boolean", description: "Did the workaround work? Omit if you never found out — 'unknown' is a real answer" },
+        kind: {
+          type: "string",
+          enum: ["failure", "surprise", "misleading_success"],
+          description: "failure = it errored; surprise = it worked but not as documented; misleading_success = it REPORTED success while the intended effect did not happen",
+        },
+      },
+      required: ["solution_id", "tool", "error"],
+    },
+  },
+
+  {
+    name: "ateam_get_lessons",
+    core: true,
+    description:
+      "Read what EARLIER runs on this solution learned — newest first, bounded. " +
+      "Call this during orientation, BEFORE planning: it is the only thing that " +
+      "carries context across runs, and it is cheap. Each entry says which tool " +
+      "misled a previous run, the verbatim error, what was tried instead, and " +
+      "whether that worked. An empty list is a real answer (nothing learned yet).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        solution_id: { type: "string", description: "The solution ID" },
+        limit: { type: "number", description: "Max entries, newest first (default 20)" },
+      },
+      required: ["solution_id"],
+    },
+  },
+
   {
     name: "ateam_create_connector",
     core: true,
@@ -1912,7 +1965,7 @@ export const tools = [
       "SHIP DEV TO PROD. Merges the `dev` branch into `main` and auto-tags the new main HEAD as safe-YYYY-MM-DD-NNN. " +
       "Use after testing your dev work, when you're ready to deploy changes to production.\n\n" +
       "Workflow: 1) ateam_github_patch (writes to dev) → 2) ateam_github_promote (merges dev→main) → 3) ateam_build_and_run (deploys main).\n\n" +
-      "Pass dry_run:true to see what's about to ship without merging. On merge conflict the call returns 409 — resolve manually on GitHub (open a PR or use the web UI), then retry.",
+      "Pass dry_run:true to see what's about to ship without merging.\n\nON 409 MERGE CONFLICT: main holds commits dev never received. Call ateam_github_sync_from_main(solution_id) to merge main into dev, then promote again. Only if THAT also returns 409 did both sides edit the same lines — that one needs a human (open a PR on GitHub).",
     inputSchema: {
       type: "object",
       properties: {
@@ -1936,6 +1989,31 @@ export const tools = [
       required: ["solution_id"],
     },
   },
+  {
+    name: "ateam_github_sync_from_main",
+    core: true,
+    description:
+      "BRING `dev` UP TO DATE WITH `main` — merges main into dev. The mirror of ateam_github_promote.\n\n" +
+      "USE THIS WHEN PROMOTE RETURNS 409. promote only ships dev→main, so the moment anything lands on main directly — a hotfix, a manual edit, an ateam_github_rollback, or a write that mis-targeted the branch — dev falls behind and can never be promoted again. Without this tool that divergence is unfixable from A-Team: the only exits are the GitHub web UI or a raw API call.\n\n" +
+      "Workflow on a 409: 1) ateam_github_diff (confirm status:'diverged') → 2) ateam_github_sync_from_main → 3) ateam_github_promote.\n\n" +
+      "Pass dry_run:true FIRST to see exactly which commits and files would come into dev without changing anything.\n\n" +
+      "This is a real merge, not a force: if main and dev edited the SAME lines it returns 409 too, and that one genuinely needs a human (open a PR).",
+    monitoring: { safe: true, cost: "low", latency_ms_p95: 2500, output: "bounded" },
+    inputSchema: {
+      type: "object",
+      properties: {
+        solution_id: {
+          type: "string",
+          description: "The solution ID",
+        },
+        dry_run: {
+          type: "boolean",
+          description: "If true: show the commits + files that would merge into dev, change nothing. Default: false. Call this first.",
+        },
+      },
+      required: ["solution_id"],
+    },
+  },
   {
     name: "ateam_github_rollback",
     core: true,
@@ -2262,7 +2340,22 @@ function toText(data) { return { content: [{ type: "text", text: JSON.stringify(
 // into the call args; refuse to operate without it (prevents cross-actor leaks).
 function getActorId(args) {
   const id = args?._adas_actor;
-  if (!id) throw new Error("${connectorId}: no actor context — _adas_actor missing.");
+  // Name BOTH causes. "actor context missing" reads as "Core did not send it",
+  // and that misreading cost a full day on 2026-08-20: Core HAD injected it and
+  // the connector's own schema validation stripped it, because that one tool's
+  // inputSchema omitted _adas_actor. An MCP server drops arguments a tool did
+  // not declare, so the field vanishes silently — and only on the tools that
+  // forgot it, which is why read tools kept working and the first write failed.
+  if (!id) {
+    throw new Error(
+      "${connectorId}: no actor context — _adas_actor missing. TWO possible causes: " +
+      "(1) this tool's inputSchema does not DECLARE _adas_actor, so MCP stripped it " +
+      "before your handler ran — add it to inputSchema.properties (see toolSchemas() " +
+      "below, every data tool must spread ...actor); or " +
+      "(2) the caller is not actor-scoped — ateam_test_connector runs as _system_service, " +
+      "so use ateam_test_skill or a real conversation to exercise per-user tools."
+    );
+  }
   return id;
 }
 ${uiCapable ? `
@@ -2292,6 +2385,13 @@ function discoverPlugins() {
 // ── Tool definitions ── Core reads this list. A tool named "ui.listPlugins"
 // is how Core knows this connector is UI-capable.
 function toolSchemas() {
+  // MUST be spread into the inputSchema.properties of EVERY per-actor tool.
+  // Not decoration: MCP strips arguments a tool did not declare, so a tool that
+  // omits these gets them removed before the handler runs and getActorId()
+  // throws — while the tools that DID declare them keep working. The result is
+  // a connector that looks healthy (deploys, lists tools, answers reads) and
+  // fails on the first write. Do not "fix" that with a default actor id: one
+  // shared actor pools every user's data.
   const actor = { _adas_actor: { type: "string" }, _adas_tenant: { type: "string" } };
   return [
     {
@@ -2315,7 +2415,33 @@ async function handle(req) {
 
   if (method === "tools/call") {
     const name = params?.name;
-    const args = params?.arguments || {};
+    // CALLER CONTEXT COMES FROM THE ENVELOPE FIRST.
+    //
+    // Core sends identity two ways: as _adas_* ARGUMENTS, and on params._meta
+    // beside the arguments object. The argument channel is fragile — a server drops
+    // arguments a tool did not declare, so a tool whose inputSchema omits
+    // _adas_actor loses it silently and only per-user WRITES fail, while reads
+    // keep working. The envelope cannot be stripped: it is not part of the
+    // validated argument object.
+    //
+    // This server reads params directly (no SDK zod validation), so _meta is
+    // simply available — no wrapper, no callback plumbing. Merge it UNDER args
+    // so an explicitly declared argument still wins, which keeps a delegation
+    // tool's own actor_id PARAMETER untouched: caller identity is transport,
+    // subject identity is payload, and they must not collide.
+    //
+    // ONLY the _adas_ prefix. _meta is the MCP envelope's OWN namespace, not
+    // ours — the spec puts progressToken in there, and clients that request
+    // progress send it on every call. Spreading the whole envelope would hand a
+    // transport token to tools as a user argument: schemas with
+    // additionalProperties:false would start rejecting previously-valid calls,
+    // tools that log or persist their arguments would record it as user data,
+    // and a future _meta key colliding with a real parameter name would
+    // overwrite it. Read the namespace we own; do not treat the envelope as input.
+    const ctx = Object.fromEntries(
+      Object.entries(params?._meta || {}).filter(([k]) => k.startsWith("_adas_")),
+    );
+    const args = { ...ctx, ...(params?.arguments || {}) };
     try {
 ${uiCapable ? `      // ── UI registry plumbing (no actor required) ──
       if (name === "ui.listPlugins") {
@@ -4802,6 +4928,9 @@ const handlers = {
   ateam_github_promote: async ({ solution_id, label, dry_run, skip_tag }, sid) =>
     post(`/deploy/solutions/${solution_id}/promote`, { label, dry_run, skip_tag }, sid),
 
+  ateam_github_sync_from_main: async ({ solution_id, dry_run }, sid) =>
+    post(`/deploy/solutions/${solution_id}/sync-from-main`, { dry_run }, sid),
+
   ateam_github_rollback: async ({ solution_id, target, tag }, sid) =>
     // Accept both `target` (new spec) and `tag` (legacy callers)
     post(`/deploy/solutions/${solution_id}/rollback`, { target: target || tag }, sid),
@@ -4926,6 +5055,23 @@ const handlers = {
     };
   },
 
+  ateam_log_lesson: async ({ solution_id, tool, error, workaround, worked, kind }, sid) => {
+    if (!solution_id) throw new Error("solution_id required");
+    if (!tool) throw new Error("tool required — the tool that misled you");
+    if (!error) throw new Error("error required — quote it VERBATIM, do not paraphrase");
+    return await post(
+      `/solutions/${solution_id}/lessons`,
+      { tool, error, workaround, worked, kind },
+      sid,
+    );
+  },
+
+  ateam_get_lessons: async ({ solution_id, limit }, sid) => {
+    if (!solution_id) throw new Error("solution_id required");
+    const qs = Number.isFinite(limit) ? `?limit=${limit}` : "";
+    return await get(`/solutions/${solution_id}/lessons${qs}`, sid);
+  },
+
   ateam_show_solution_minimal: async ({ solution_id }, sid) => {
     if (!solution_id) throw new Error("solution_id required");
     const full = await get(`/deploy/solutions/${solution_id}/definition`, sid);