@aioproductoscom/mcp 0.15.9 → 0.15.10

package/README.md

@@ -41,39 +41,68 @@ at a self-hosted platform.
 ### Prefer no local install? Use the hosted remote
 
 AIOProductOS is also a **hosted remote MCP** (OAuth 2.1 sign-in, no token
-pasting, 38 tools) — add the custom connector URL
+pasting, the same 71 tools) — add the custom connector URL
 `https://platform.aioproductos.com/api/mcp` in Claude.ai, Claude Code, or any
 remote-capable MCP host. Listed on the
 [official MCP Registry](https://registry.modelcontextprotocol.io) as
 `com.aioproductos/mcp` and [verified on Glama](https://glama.ai/mcp/connectors/com.aioproductos/mcp).
 
-## Tools
-
-| Tool | What it does |
-|---|---|
-| `whoami` | the connected org + member |
-| `pm_meta` | lists / statuses / members / features (resolve names → ids) |
-| `list_tasks` | list tasks (filter by `status_id`, `list_id`) |
-| `get_task` | one task + comments + assignees |
-| `create_task` | new task; `feature_id` / `insight_id` link it to the spine |
-| `update_task` | change status, priority, fields, assignees |
-| `comment_on_task` | add a comment |
-| `get_product_brain` | a grounded read-only snapshot of your product (revenue, accounts, web + product analytics, features, signals, open work) |
-| `analyze_funnel` | build an ordered conversion funnel from your events (users per step, conversion, drop-off); omit steps to list available events |
-| `get_retention` | weekly cohort retention — who comes back, week over week |
-| `analyze_paths` | user paths (Sankey) — what people do after a start event, with drop-off |
-| `list_conversations` | the support-chat inbox (open threads, visitor, topic, status) |
-| `get_conversation` | one support thread + its full message history |
-| `reply_to_conversation` | reply to a visitor (**visible in their chat widget**, sent as you) |
-| `add_note` | internal triage note on a conversation (never shown to the visitor) |
-| `resolve_conversation` | mark a conversation resolved |
-| `list_bookings` | scheduled calls/meetings (upcoming by default) |
-| `cancel_booking` | cancel a booking (frees the slot, cancels the meeting) |
-| `reschedule_booking` | move a booking to a new open slot |
-| `list_channels` | the team Comms channels you belong to |
-| `read_channel` | recent messages in a channel (catch up before replying) |
-| `post_to_channel` | post into a team channel — visible live to teammates, as you |
-| `reply_in_channel` | reply in a thread under a message |
+## Tools — 71
+
+It reads **and** writes across the whole strategy-to-delivery ladder, so an
+assistant can run product work end to end instead of reporting on it. Identical
+tool set to the hosted remote connector.
+
+**Orientation** — `whoami` (org + member), `get_pm_playbook` (how to operate),
+`pm_meta` (lists / statuses / members / features — resolve names → ids)
+
+**Grounding** — `get_product_brain` (revenue, accounts, analytics, features,
+signals, open work in one read), `get_weekly_signal_memo`, `get_customer_360`
+(money + people + voice for one account), `get_codebase_map`
+
+**Discovery — ideas** — `list_ideas`, `create_idea`, `update_idea`, `vote_idea`,
+`promote_idea` (idea → feature)
+
+**Strategy — initiatives & OKRs** — `list_initiatives`, `create_initiative`,
+`update_initiative`, `list_objectives`, `create_objective`, `update_objective`,
+`update_key_result`
+
+**Roadmap** — `list_features`, `create_feature`, `update_feature`,
+`list_releases`, `create_release`, `update_release`, `get_roadmap_drift`
+(planned vs shipped, scored)
+
+**Delivery — board & sprints** — `list_tasks`, `get_task`, `create_task`,
+`update_task`, `delete_task`, `comment_on_task`, `list_sprints`, `create_sprint`,
+`update_sprint`
+
+**Docs & decisions** — `list_pages`, `get_page`, `create_page`, `update_page`,
+`list_decisions`, `create_decision`, `update_decision`
+
+**Experiments** — `list_experiments`, `create_experiment`, `update_experiment`
+
+**Voice of customer** — `list_insights`, `capture_insight`
+
+**Analytics** — `analyze_nps`, `analyze_nrr` (both revenue-weighted),
+`analyze_funnel`, `get_retention`, `analyze_paths`
+
+**Support inbox** — `list_conversations`, `get_conversation`,
+`reply_to_conversation` (**visible in the visitor's chat widget**), `add_note`
+(internal only), `resolve_conversation`
+
+**Scheduling** — `list_bookings`, `cancel_booking`, `reschedule_booking`
+
+**Team comms** — `list_channels`, `read_channel`, `post_to_channel`,
+`reply_in_channel`
+
+**Identity graph** — `get_device_candidates`, `merge_end_users`,
+`unmerge_end_users` (reversible 30 days), `list_identity_merges`
+
+**AI artifacts** — `review_artifact` (critic vs your PM bar),
+`list_artifact_versions`, `revert_to_version`
+
+Every tool declares read-only / write / destructive hints, so a host can gate
+them. `delete_task` is the only destructive one. Writes are scoped to your org
+and respect your role's permissions — the token can never reach another tenant.
 
 > For an assignable **coding teammate** (Backend / Frontend / Mobile / QA that
 > opens PRs in your repo), install the separate

package/dist/client.js

@@ -205,4 +205,153 @@ export class PlatformClient {
             body: JSON.stringify({ action: "reply", channel_id: channelId, parent_id: parentId, body }),
         });
     }
+    // ---- Strategy ladder: initiatives + ideas (goal → initiative → feature) ----
+    listInitiatives(productId) {
+        const qs = productId ? `?product_id=${encodeURIComponent(productId)}` : "";
+        return this.req(`/api/me/initiatives${qs}`);
+    }
+    createInitiative(body) {
+        return this.req("/api/me/initiatives", { method: "POST", body: JSON.stringify(body) });
+    }
+    updateInitiative(id, body) {
+        return this.req(`/api/me/initiatives/${encodeURIComponent(id)}`, { method: "PATCH", body: JSON.stringify(body) });
+    }
+    listIdeas(opts) {
+        const p = new URLSearchParams();
+        if (opts.status)
+            p.set("status", opts.status);
+        if (opts.productId)
+            p.set("product_id", opts.productId);
+        const qs = p.toString();
+        return this.req(`/api/me/ideas${qs ? `?${qs}` : ""}`);
+    }
+    createIdea(body) {
+        return this.req("/api/me/ideas", { method: "POST", body: JSON.stringify(body) });
+    }
+    updateIdea(id, body) {
+        return this.req(`/api/me/ideas/${encodeURIComponent(id)}`, { method: "PATCH", body: JSON.stringify(body) });
+    }
+    voteIdea(id, remove) {
+        return this.req(`/api/me/ideas/${encodeURIComponent(id)}/vote`, { method: remove ? "DELETE" : "POST" });
+    }
+    promoteIdea(id, body) {
+        return this.req(`/api/me/ideas/${encodeURIComponent(id)}/promote`, { method: "POST", body: JSON.stringify(body) });
+    }
+    // ---- Read parity with the hosted connector: catalogue + strategy + docs ----
+    listFeatures(opts) {
+        const p = new URLSearchParams();
+        if (opts.q)
+            p.set("q", opts.q);
+        if (opts.productId)
+            p.set("product_id", opts.productId);
+        const qs = p.toString();
+        return this.req(`/api/me/features${qs ? `?${qs}` : ""}`);
+    }
+    listObjectives(productId) {
+        const qs = productId ? `?product_id=${encodeURIComponent(productId)}` : "";
+        return this.req(`/api/me/objectives${qs}`);
+    }
+    listExperiments(opts) {
+        const p = new URLSearchParams();
+        if (opts.productId)
+            p.set("product_id", opts.productId);
+        if (opts.state)
+            p.set("state", opts.state);
+        const qs = p.toString();
+        return this.req(`/api/me/experiments${qs ? `?${qs}` : ""}`);
+    }
+    listReleases(productId) {
+        const qs = productId ? `?product_id=${encodeURIComponent(productId)}` : "";
+        return this.req(`/api/me/releases${qs}`);
+    }
+    listSprints(state) {
+        const qs = state ? `?state=${encodeURIComponent(state)}` : "";
+        return this.req(`/api/me/sprints${qs}`);
+    }
+    listPages(productId) {
+        const qs = productId ? `?product_id=${encodeURIComponent(productId)}` : "";
+        return this.req(`/api/me/pages${qs}`);
+    }
+    getPage(id) {
+        return this.req(`/api/me/pages?id=${encodeURIComponent(id)}`);
+    }
+    listInsights(opts) {
+        const p = new URLSearchParams();
+        if (opts.q)
+            p.set("q", opts.q);
+        if (opts.status)
+            p.set("status", opts.status);
+        if (opts.kind)
+            p.set("kind", opts.kind);
+        if (opts.featureId)
+            p.set("feature_id", opts.featureId);
+        if (opts.accountId)
+            p.set("account_id", opts.accountId);
+        if (opts.productId)
+            p.set("product_id", opts.productId);
+        if (opts.limit)
+            p.set("limit", String(opts.limit));
+        const qs = p.toString();
+        return this.req(`/api/me/insights${qs ? `?${qs}` : ""}`);
+    }
+    roadmapDrift(opts) {
+        const p = new URLSearchParams();
+        if (opts.window)
+            p.set("window", opts.window);
+        if (opts.productId)
+            p.set("product_id", opts.productId);
+        const qs = p.toString();
+        return this.req(`/api/me/roadmap-drift${qs ? `?${qs}` : ""}`);
+    }
+    weeklySignalMemo(opts) {
+        const p = new URLSearchParams();
+        if (opts.week)
+            p.set("week", opts.week);
+        if (opts.generate)
+            p.set("generate", "1");
+        const qs = p.toString();
+        return this.req(`/api/me/weekly-signal${qs ? `?${qs}` : ""}`);
+    }
+    codebaseMap(productId) {
+        const qs = productId ? `?product_id=${encodeURIComponent(productId)}` : "";
+        return this.req(`/api/me/codebase${qs}`);
+    }
+    listArtifactVersions(opts) {
+        const p = new URLSearchParams();
+        if (opts.targetId)
+            p.set("target_id", opts.targetId);
+        if (opts.targetType)
+            p.set("target_type", opts.targetType);
+        const qs = p.toString();
+        return this.req(`/api/me/artifact-versions${qs ? `?${qs}` : ""}`);
+    }
+    // ---- Identity graph: candidates, merge history, merge / unmerge ----
+    deviceCandidates() {
+        return this.req("/api/me/identity");
+    }
+    listIdentityMerges(limit) {
+        const p = new URLSearchParams({ view: "merges" });
+        if (limit)
+            p.set("limit", String(limit));
+        return this.req(`/api/me/identity?${p.toString()}`);
+    }
+    mergeEndUsers(body) {
+        return this.req("/api/me/identity", {
+            method: "POST",
+            body: JSON.stringify({ action: "merge_end_users", ...body }),
+        });
+    }
+    unmergeEndUsers(eventId) {
+        return this.req("/api/me/identity", {
+            method: "POST",
+            body: JSON.stringify({ action: "unmerge_end_users", event_id: eventId }),
+        });
+    }
+    // ---- AI artifacts: critic review + version revert ----
+    reviewArtifact(body) {
+        return this.req("/api/me/review-artifact", { method: "POST", body: JSON.stringify(body) });
+    }
+    revertToVersion(body) {
+        return this.req("/api/me/revert-version", { method: "POST", body: JSON.stringify(body) });
+    }
 }

package/dist/index.js

@@ -5,7 +5,7 @@ import { z } from "zod";
 import { PlatformClient } from "./client.js";
 import { PM_PLAYBOOK, PM_SKILL_VERSION } from "./pm-skill.js";
 import { checkForUpdate, updateBanner } from "./update-notifier.js";
-const VERSION = "0.15.7";
+const VERSION = "0.15.10";
 const token = process.env.PRODUCTOS_TOKEN;
 const baseUrl = (process.env.PRODUCTOS_URL ?? "https://platform.aioproductos.com").replace(/\/$/, "");
 if (!token) {
@@ -62,6 +62,8 @@ server.tool("create_feature", "Create a feature on the product spine and return
     name: z.string().describe("Feature name (the only required field), e.g. 'SAML SSO'."),
     description: z.string().optional().describe("What the feature is / why it matters (optional)."),
     product_id: z.string().optional().describe("Product to create it under, from whoami (optional; the org's primary product when omitted)."),
+    initiative_id: z.string().optional().describe("Initiative to align this feature under for line-of-sight, from list_initiatives (optional)."),
+    objective_id: z.string().optional().describe("Objective (goal) to align this feature under directly when there's no intermediate initiative, from list_objectives (optional)."),
 }, async (a) => text(await client.createFeature(a)));
 server.tool("create_objective", "Create an objective (OKR), optionally with key results, and return it. period is free text (e.g. 'Q3 2026'); product_id and parent_id (a parent objective) are optional and verified in-org. Each key result takes name + optional unit / start_value / target_value. Only name is required.", {
     name: z.string().describe("Objective name (the only required field), e.g. 'Reach $50k MRR'."),
@@ -100,6 +102,8 @@ server.tool("update_feature", "Update a feature and return it; omitted fields ar
     status: z.enum(["active", "discovered", "archived"]).optional().describe("Lifecycle status (optional)."),
     target_date: z.string().nullable().optional().describe("Target ship date 'YYYY-MM-DD', or null to clear (optional)."),
     mark_shipped: z.boolean().optional().describe("true stamps the ship date now; false clears it (optional)."),
+    initiative_id: z.string().nullable().optional().describe("Align under this initiative (line-of-sight), from list_initiatives; null unlinks (optional)."),
+    objective_id: z.string().nullable().optional().describe("Align directly under this objective, from list_objectives; null unlinks (optional)."),
 }, async (a) => text(await client.updateFeature(a)));
 server.tool("update_objective", "Update an objective's name / description / period and return it; omitted fields are unchanged (null clears description or period). Resolve the id via list_objectives; only id is required. To move a key result's value use update_key_result.", {
     id: z.string().describe("Objective id, from list_objectives (required)."),
@@ -115,6 +119,49 @@ server.tool("update_key_result", "Update a key result — most often to move cur
     name: z.string().optional().describe("New name (optional)."),
     unit: z.string().nullable().optional().describe("New unit, e.g. 'USD'; null clears it (optional)."),
 }, async (a) => text(await client.updateKeyResult(a)));
+server.tool("list_initiatives", "List the org's initiatives — the strategic layer between goals and features (goal → initiative → feature → epic → release). Each returns its name, status, timeframe, the objective it rolls up to (if any), and its linked-feature count. Read-only. Resolve an initiative id here before create_feature / update_feature (initiative_id) or update_initiative.", {
+    product_id: z.string().optional().describe("Only initiatives for this product, from whoami (optional)."),
+}, async (a) => text(await client.listInitiatives(a.product_id)));
+server.tool("create_initiative", "Create an initiative — a strategic effort that groups features and rolls up to a goal — and return it. Link it to a goal with objective_id (from list_objectives) to build line-of-sight. status is planned|active|paused|done|abandoned (default planned); timeframe is free text ('H2 2026'). product_id defaults to the primary product. Only name is required. Then align features to it via create_feature / update_feature (initiative_id).", {
+    name: z.string().describe("Initiative name (the only required field), e.g. 'Win enterprise'."),
+    description: z.string().optional().describe("What the initiative is / why it matters (optional)."),
+    objective_id: z.string().optional().describe("Goal this rolls up to, from list_objectives (optional; builds line-of-sight)."),
+    status: z.enum(["planned", "active", "paused", "done", "abandoned"]).optional().describe("Lifecycle status (optional; default 'planned')."),
+    timeframe: z.string().optional().describe("Free-text timeframe, e.g. 'Q3 2026' or 'H2 2026' (optional)."),
+    product_id: z.string().optional().describe("Product to scope it to, from whoami (optional)."),
+}, async (a) => text(await client.createInitiative(a)));
+server.tool("update_initiative", "Update an initiative and return it; omitted fields are unchanged. Re-point it to a different goal with objective_id (null unlinks). status is planned|active|paused|done|abandoned. Resolve the id via list_initiatives; only id is required.", {
+    id: z.string().describe("Initiative id, from list_initiatives (required)."),
+    name: z.string().optional().describe("New name (optional)."),
+    description: z.string().nullable().optional().describe("New description; null clears it (optional)."),
+    objective_id: z.string().nullable().optional().describe("New parent goal, from list_objectives; null unlinks (optional)."),
+    status: z.enum(["planned", "active", "paused", "done", "abandoned"]).optional().describe("Lifecycle status (optional)."),
+    timeframe: z.string().nullable().optional().describe("New timeframe; null clears it (optional)."),
+}, async (a) => text(await client.updateInitiative(a.id, a)));
+server.tool("list_ideas", "List the org's ideas — the native, votable idea backlog — ranked by vote count (highest first). Each returns title, status, vote count, author, and the feature it was promoted to (if any). status is new|under_review|planned|promoted|declined (optional filter). Read-only. Ideas are distinct from insights: an idea is a proposal a team votes on; an insight is customer evidence. Resolve an idea id here before update_idea / vote_idea / promote_idea.", {
+    status: z.enum(["new", "under_review", "planned", "promoted", "declined"]).optional().describe("Filter by status (optional)."),
+    product_id: z.string().optional().describe("Only ideas for this product, from whoami (optional)."),
+}, async (a) => text(await client.listIdeas({ status: a.status, productId: a.product_id })));
+server.tool("create_idea", "Create an idea in the backlog and return it (starts with 0 votes, status 'new'). Link the evidence it came from with insight_id (from list_insights). product_id defaults to the primary product. Only title is required. Grow it with vote_idea, then promote_idea turns the winner into a roadmap feature.", {
+    title: z.string().describe("Idea title (the only required field), e.g. 'Bulk-edit tasks'."),
+    body: z.string().optional().describe("The idea in more detail (optional)."),
+    insight_id: z.string().optional().describe("Customer insight this idea came from, from list_insights (optional; welds evidence to the idea)."),
+    product_id: z.string().optional().describe("Product to scope it to, from whoami (optional)."),
+}, async (a) => text(await client.createIdea(a)));
+server.tool("update_idea", "Update an idea's title / body / status and return it; omitted fields unchanged. status is new|under_review|planned|promoted|declined (set 'promoted' via promote_idea instead, so a feature is actually created). Resolve the id via list_ideas; only id is required.", {
+    id: z.string().describe("Idea id, from list_ideas (required)."),
+    title: z.string().optional().describe("New title (optional)."),
+    body: z.string().nullable().optional().describe("New body; null clears it (optional)."),
+    status: z.enum(["new", "under_review", "planned", "promoted", "declined"]).optional().describe("New status (optional; prefer promote_idea over setting 'promoted' by hand)."),
+}, async (a) => text(await client.updateIdea(a.id, a)));
+server.tool("vote_idea", "Cast (or remove) the connected member's vote on an idea and return the new vote state. Adds your vote by default; pass remove:true to take it back. One vote per member — voting twice is a no-op. Resolve the id via list_ideas; only id is required.", {
+    id: z.string().describe("Idea id, from list_ideas (required)."),
+    remove: z.boolean().optional().describe("true removes your vote instead of adding it (optional; default false)."),
+}, async (a) => text(await client.voteIdea(a.id, a.remove)));
+server.tool("promote_idea", "Promote an idea into a roadmap feature: creates a feature from the idea (name + description), stamps the idea 'promoted' and links it to the new feature, and returns the feature id. Idempotent — an already-promoted idea returns its existing feature. Resolve the id via list_ideas; only id is required. Align the new feature to an initiative/goal afterwards with update_feature.", {
+    id: z.string().describe("Idea id to promote, from list_ideas (required)."),
+    product_id: z.string().optional().describe("Product to create the feature under, from whoami (optional)."),
+}, async (a) => text(await client.promoteIdea(a.id, a)));
 server.tool("update_sprint", "Update a sprint and return it. state is 'future' | 'active' | 'closed' — moving to 'closed' stamps the completion time, reopening clears it. start_date / end_date are ISO 8601 (or null to clear). Resolve the id via list_sprints; only id is required.", {
     id: z.string().describe("Sprint id, from list_sprints (required)."),
     name: z.string().optional().describe("New name (optional)."),
@@ -257,6 +304,69 @@ server.tool("reply_in_channel", "Reply in a thread under a specific message in a
     parent_id: z.string().describe("Parent message id, from read_channel."),
     body: z.string().describe("Reply text, visible to all channel members."),
 }, async (a) => text(await client.replyInChannel(a.channel_id, a.parent_id, a.body)));
+// ── Read parity with the hosted connector ───────────────────────────────────
+// The full catalogue + strategy ladder + docs + identity + artifact reads, so
+// the stdio agent grounds on exactly what the hosted connector sees.
+server.tool("list_features", "The product's feature catalogue with description, status, and when each was last touched — richer than pm_meta (id+name only). Read-only; empty when none. Optional product_id (from whoami) and free-text q over name+key. Use a feature id from here to link a task or insight on the spine.", {
+    q: z.string().optional().describe("Free-text search over feature name + key (optional)."),
+    product_id: z.string().optional().describe("Product id to scope to, from whoami (optional; spans all products when omitted)."),
+}, async (a) => text(await client.listFeatures({ q: a.q, productId: a.product_id })));
+server.tool("list_objectives", "List the org's OKRs — each objective with its key results and live progress (0..1 between start and target). Read-only; empty when none set. Read it before prioritising; tie proposed tasks to the objective they move and cite live progress when arguing priority. Optional product_id, from whoami.", { product_id: z.string().optional().describe("Product id to scope to, from whoami (optional; spans all products when omitted).") }, async (a) => text(await client.listObjectives(a.product_id)));
+server.tool("list_experiments", "List the org's experiments with their state and linked feature. Read-only; empty when none. Optional product_id (from whoami) and state filter. Use an experiment id from here with review_artifact or list_artifact_versions.", {
+    product_id: z.string().optional().describe("Product id to scope to, from whoami (optional; spans all products when omitted)."),
+    state: z.string().optional().describe("Only experiments in this state (optional)."),
+}, async (a) => text(await client.listExperiments({ productId: a.product_id, state: a.state })));
+server.tool("list_releases", "List the org's releases (version, date, linked features). Read-only; empty when none. Optional product_id, from whoami. Use it to see what shipped and when, then open slipped work with list_features or get_roadmap_drift.", { product_id: z.string().optional().describe("Product id to scope to, from whoami (optional; spans all products when omitted).") }, async (a) => text(await client.listReleases(a.product_id)));
+server.tool("list_sprints", "List the org's sprints with their state and dates. Read-only; empty when none. Optional state filter (e.g. active | planned | closed). Resolve a sprint id here before scheduling tasks into it via update_task / update_sprint.", { state: z.string().optional().describe("Only sprints in this state, e.g. active | planned | closed (optional).") }, async (a) => text(await client.listSprints(a.state)));
+server.tool("list_pages", "List the org's Pages (docs / PRDs) with title and last-updated — id+title for resolution. Read-only; empty when none. Optional product_id, from whoami. Get one page's full content with get_page.", { product_id: z.string().optional().describe("Product id to scope to, from whoami (optional; spans all products when omitted).") }, async (a) => text(await client.listPages(a.product_id)));
+server.tool("get_page", "Read one Page (doc / PRD) by id and return its full content. Read-only. Resolve the id first with list_pages — never guess it.", { id: z.string().describe("Page id, from list_pages.") }, async (a) => text(await client.getPage(a.id)));
+server.tool("list_insights", "Search the captured insight backlog (voice of customer) — the read twin of capture_insight. Read-only; matching insights newest first, empty when nothing matches. Filters: status, kind (insight|opportunity), feature_id, account_id, product_id, free-text q over title+body; limit default 50, max 200. Survey the evidence behind a feature or account before prioritising.", {
+    q: z.string().optional().describe("Free-text search over title + body (optional)."),
+    status: z.string().optional().describe("Only insights in this workflow status (optional)."),
+    kind: z.enum(["insight", "opportunity"]).optional().describe("'insight' = raw signal; 'opportunity' = a prioritisable ask (optional)."),
+    feature_id: z.string().optional().describe("Only insights linked to this feature; id via list_features or pm_meta (optional)."),
+    account_id: z.string().optional().describe("Only insights about this account; id via get_customer_360 (optional)."),
+    product_id: z.string().optional().describe("Product id to scope to, from whoami (optional; spans all products when omitted)."),
+    limit: z.number().int().min(1).max(200).optional().describe("Max rows to return (optional; default 50, max 200)."),
+}, async (a) => text(await client.listInsights({
+    q: a.q,
+    status: a.status,
+    kind: a.kind,
+    featureId: a.feature_id,
+    accountId: a.account_id,
+    productId: a.product_id,
+    limit: a.limit,
+})));
+server.tool("get_roadmap_drift", "Planned vs shipped features over a window: a drift score (0-100, 100 = perfect alignment), counts (planned / shipped / on-time / slipped / unplanned / orphaned), median slip days, and the top slipped + unplanned ships. Deterministic, no LLM cost. window = week | month | quarter (default quarter); optional product_id. Read-only; zeroed when nothing was planned or shipped. Use it in planning reviews, then open slipped features with list_features.", {
+    window: z.enum(["week", "month", "quarter"]).optional().describe("Lookback window to compare planned vs shipped (optional; default quarter)."),
+    product_id: z.string().optional().describe("Product id, from whoami (optional; spans all the org's products when omitted)."),
+}, async (a) => text(await client.roadmapDrift({ window: a.window, productId: a.product_id })));
+server.tool("get_weekly_signal_memo", "The deterministic weekly signal memo — what moved on the spine this week (revenue, top accounts, fresh verbatim signal, shipped + slipped work). Read-only. Optional week (ISO week, e.g. 2026-W29; defaults to the current week); set generate=true to (re)compute it if this week's memo isn't cached yet.", {
+    week: z.string().optional().describe("ISO week, e.g. '2026-W29' (optional; defaults to the current week)."),
+    generate: z.boolean().optional().describe("Recompute the memo if it isn't cached yet (optional)."),
+}, async (a) => text(await client.weeklySignalMemo({ week: a.week, generate: a.generate })));
+server.tool("get_codebase_map", "The product's codebase map — modules and how they connect, with live spine pulses (recent deploys / activity). Read-only. Optional product_id, from whoami. Use it to ground engineering-adjacent questions in the actual code structure.", { product_id: z.string().optional().describe("Product id to scope to, from whoami (optional; spans all products when omitted).") }, async (a) => text(await client.codebaseMap(a.product_id)));
+server.tool("list_artifact_versions", "List the immutable version history of one AI artifact (a feature spec, experiment plan, or page) — each version with its score and when it was written. Read-only. Resolve target_id via list_features / list_experiments / list_pages first. Pair with revert_to_version to roll one back, or review_artifact to add a new reviewed version.", {
+    target_id: z.string().optional().describe("Id of the feature / experiment / page whose versions to list, from list_features / list_experiments / list_pages."),
+    target_type: z.enum(["feature", "experiment", "page"]).optional().describe("What kind of artifact target_id is (optional)."),
+}, async (a) => text(await client.listArtifactVersions({ targetId: a.target_id, targetType: a.target_type })));
+server.tool("get_device_candidates", "Clusters of ≥2 end-users seen on the same device: 'anon_bridge' (high confidence — an anonymous visitor later identified) or 'device_shared' (low confidence — review only). Read-only; empty when none found. Use it to find merge targets, then act with merge_end_users.", {}, async () => text(await client.deviceCandidates()));
+server.tool("list_identity_merges", "List the org's end-user merge history, newest first — each event with its id, kind (merge | unmerge), target + source ids, reason, who ran it, when, and whether a merge was already reverted. Read-only; empty when none have run. Use it to audit identity changes and find the event id for unmerge_end_users (only un-reverted merges can be undone).", { limit: z.number().int().min(1).max(200).optional().describe("Max events to return (optional; default 50, max 200).") }, async (a) => text(await client.listIdentityMerges(a.limit)));
+server.tool("merge_end_users", "Merge source end-users into a target and return the result, including the merge event id (also in list_identity_merges): all FK rows (events, insights, tasks, …) re-point onto the target and the sources are tombstoned. A write; reversible for 30 days via unmerge_end_users. Get the candidate ids from get_device_candidates first — never guess which users to fold together.", {
+    target_end_user_id: z.string().describe("UUID of the end-user to keep, from get_device_candidates."),
+    source_end_user_ids: z.array(z.string()).describe("UUIDs of end-users to fold into the target, from get_device_candidates."),
+    reason: z.string().optional().describe("Why the merge (optional, recorded)."),
+}, async (a) => text(await client.mergeEndUsers({ target_end_user_id: a.target_end_user_id, source_end_user_ids: a.source_end_user_ids, reason: a.reason })));
+server.tool("unmerge_end_users", "Undo a previous end-user merge by its event id and return the result — the tombstoned sources are restored and rows re-split. A write; only an un-reverted merge event can be undone. Find the event id with list_identity_merges — never guess it.", { event_id: z.string().describe("Merge event id to undo, from list_identity_merges.") }, async (a) => text(await client.unmergeEndUsers(a.event_id)));
+server.tool("review_artifact", "Agent-as-critic over a DRAFT artifact (a feature spec, experiment plan, or page): checks it against a baseline PM bar — clear problem/hypothesis, a measurable success metric, evidence cited, risks named, a rollout/experiment plan — and returns structured findings (section, severity, concrete fix, verbatim evidence quote) plus a 0-100 score. A write: each call re-runs the review and persists a new version (see list_artifact_versions). Resolve target_id first via list_features / list_experiments / list_pages. One small LLM call; use it before sending a draft for sign-off.", {
+    target_id: z.string().describe("Id of the feature / experiment / page to review, from list_features / list_experiments / list_pages."),
+    target_type: z.enum(["feature", "experiment", "page"]).describe("What kind of artifact target_id is: a feature (spec), experiment (plan), or page (doc/PRD)."),
+    rubric_id: z.string().optional().describe("Score against a specific rubric; omit to use the org's default (or the built-in baseline)."),
+}, async (a) => text(await client.reviewArtifact({ target_id: a.target_id, target_type: a.target_type, rubric_id: a.rubric_id })));
+server.tool("revert_to_version", "Roll an AI artifact back to a prior version by version_id and return the result — the artifact's live content is replaced with that version's, recorded as a new version so nothing is lost. A write. Find the version_id with list_artifact_versions — never guess it.", {
+    version_id: z.string().describe("Version id to revert to, from list_artifact_versions."),
+    reason: z.string().optional().describe("Why the revert (optional, recorded)."),
+}, async (a) => text(await client.revertToVersion({ version_id: a.version_id, reason: a.reason })));
 // ── Routines (slash-command prompts) ────────────────────────────────────────
 // Surface in the AI host as named slash commands (e.g. Claude Code:
 // /productos:standup), so the human — or a scheduled headless run — can run a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aioproductoscom/mcp",
-  "version": "0.15.9",
+  "version": "0.15.10",
   "mcpName": "com.aioproductos/mcp",
   "description": "AIOProductOS MCP — manage the board, read your product brain + analytics, and run the support inbox from Claude Code, Cursor, Codex, and any MCP host.",
   "type": "module",
@@ -37,11 +37,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build",
-    "start": "node dist/index.js"
-  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
     "zod": "^3.23.8"
@@ -49,5 +44,9 @@
   "devDependencies": {
     "@types/node": "^22.7.0",
     "typescript": "^5.6.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
   }
-}
+}