@sentientui/mcp 0.17.7 → 0.18.1

package/AGENTS.md

@@ -43,6 +43,9 @@ Server keys start with `sk_` — required for the management API. Public keys (`
 | `get_variant_brief` | **Start here to optimize a component.** Insight-driven brief for writing a new CODE-NATIVE variant: performance, audience, insights, data-sufficiency + best-practice fallback, and code instructions |
 | `create_variant` | Creates a no-code **managed text** DRAFT — user must activate in dashboard. Fallback only; not for code-native variants |
 | `pause_variant` | Stops traffic; no MCP resume |
+| `get_cell_matrix` | "Who sees what": per-(visitor type, region) generation state + traffic share. A missing cell = they see the original |
+| `get_cell_detail` | One cell's generated option, its stored rationale, and a plain-language performance verdict |
+| `generate_cell` | Queues async AI generation for one cell (also retries failed ones). Paid plan; check `get_cell_matrix` for progress |
 
 ## Canonical Workflows
 

package/README.md

@@ -101,7 +101,12 @@ A sandboxed demo token is provisioned automatically — 10 calls/month, read-onl
 | `get_variant_brief` | Insight-driven brief for writing a new **code-native** variant: performance, audience, insights, data-sufficiency (with a best-practice fallback when there's no data yet), and step-by-step code instructions |
 | `create_variant` | Create a no-code (managed) text variant (Starter+) — fallback for text-only variants without a code change |
 | `pause_variant` | Pause a variant to stop traffic assignment |
+| `get_cell_matrix` | The "Who sees what" matrix: which visitor types have an AI-generated version live in each personalizable region, with traffic share and auto-fill status |
+| `get_cell_detail` | One cell's story: the generated option, why it was written (stored rationale), and how it performs vs the original |
+| `generate_cell` | Queue AI generation of a version for one (visitor type, region) cell — brand-locked, live in under a minute (paid plan) |
 
+> **Generated versions.** An `<Adaptive id="…">` that wraps your original as children (no `variants`) registers as a personalizable region once it is mounted and deployed. Its versions per visitor type are written in SentientUI — inspect and fill them with `get_cell_matrix`, `get_cell_detail`, and `generate_cell` — with no code change or redeploy.
+>
 > **Code-native vs no-code variants.** Variants you declare in your app (`<Adaptive variants={{…}}>`) register automatically the first time the SDK requests an assignment after you deploy — they go live immediately and need **no** `create_variant` call. Use `create_variant` only for **no-code** variants whose content is stored in SentientUI and rendered without a code change; these start as drafts you activate from the dashboard.
 >
 > **Optimizing a component?** Call `get_variant_brief` first. It returns the component's performance, audience, insights, and a data-sufficiency assessment — then your AI assistant writes a new on-brand variant directly into your code (which auto-registers on deploy). When there's no data yet, the brief falls back to best-practice priors for your project's context type so the assistant still makes a sensible change.

package/dist/{chunk-5PR2LCNN.js → chunk-HEMPCGWX.js}

@@ -1789,8 +1789,9 @@ import { z as z13 } from "zod";
 var GUIDE = `# SentientUI integration guide \u2014 the adaptive ladder
 
 SentientUI adapts a site per visitor type (personas), learning from real conversions. Each
-project has its own persona vocabulary (dashboard -> Settings -> Personas; the default is
-buyer, researcher, deal_seeker, browser + unknown). Personas are inferred from behavior \u2014 or
+project has its own persona vocabulary (dashboard -> Settings -> Personas), and it starts
+EMPTY: every visitor is 'unknown' until a persona exists, and the optimizer learns across all
+traffic pooled in the meantime. Personas are DISCOVERED from behavior \u2014 or, far faster,
 DECLARED by the app when it already knows the visitor's role: init({ persona: 'admin' }) /
 <AdaptiveProvider persona=...> / window.sentient.persona. Declared beats inferred and serves
 at full confidence; unrecognized values are ignored server-side and surfaced in the dashboard
@@ -1807,8 +1808,9 @@ time.
    other React apps use <AdaptiveProvider> from '@sentientui/react') and add
    suppressHydrationWarning to <html> \u2014 an inline script sets persona attributes pre-paint.
    Nothing adapts and nothing is tracked until this wrap is in place.
-3. \`npm run dev\`, then open the app with \`?sentient_persona=buyer\` vs
-   \`?sentient_persona=deal_seeker\` to see it adapt. No API key needed (keyless local mode).
+3. \`npm run dev\`, then open the app with \`?sentient_persona=a\` vs
+   \`?sentient_persona=b\` to see it adapt \u2014 in keyless local mode any key drives the built-in
+   heuristic. No API key needed. Against a real project the key must be one you declared.
 4. To learn from real traffic: create a project at https://sentient-ui.com and set
    NEXT_PUBLIC_SENTIENT_API_KEY=pk_... in .env.local.
 
@@ -1817,8 +1819,8 @@ time.
 Persona attributes on <html> (zero declaration; the attribute carries the project's own
 vocabulary keys \u2014 declared or inferred):
 
-    html[data-sentient-persona='deal_seeker'] .discount-banner { display: block; }
-    html[data-sentient-confidence='low'] .discount-banner { display: none; }
+    html[data-sentient-persona='admin'] .admin-tools { display: block; }
+    html[data-sentient-confidence='low'] .admin-tools { display: none; }
 
 Learned style tokens (element-scoped, SSR-safe):
 
@@ -1833,14 +1835,35 @@ prefers-reduced-motion: reduce override in CSS.
 
 ## Rung 2 \u2014 Swap (alternate content)
 
+Generated versions (start here) \u2014 wrap what the page shows today; the children are the
+original:
+
+    <Adaptive id="hero-cta" goal="signup_click">
+      <a href="/signup">Start free trial</a>
+    </Adaptive>
+
+Mount + deploy registers the region. SentientUI writes versions per visitor type in the
+dashboard ("Who sees what") \u2014 no redeploy. The children render for holdout traffic, unknown
+visitor types, types with no version yet, and every error path. No server preload: mounted
+regions are requested in one batched call. First visit shows the original briefly, then swaps;
+return visits start from the last version. Keyless local mode renders originals only. Pass
+onFormSubmit to allow form versions; set reportBaselineText={false} on regions wrapping
+personalized or account content. (Formerly <AdaptiveSlot>.)
+
+Code variants \u2014 when you write the alternatives yourself:
+
+    <Adaptive id="buy-box" goal="buy_click"                      // goal REQUIRED
+      variants={{ control: <CalmBuyBox/>, urgent: <UrgentBuyBox/> }} />  // first key = baseline
+
+    // hook form:
     const { value, bind } = useAdaptive('buy-box', {
       variants: { calm: <CalmBuyBox/>, urgent: <UrgentBuyBox/> },  // first key = baseline
       goal: 'buy_click',                                            // REQUIRED
     });
     return <div {...bind}>{value}</div>;
 
-Always attach bind \u2014 it wires exposure tracking and goal listeners. <Adaptive> is the wrapper
-form; <AdaptiveText> swaps dashboard-managed text.
+Children or variants on one <Adaptive>, never both. With the hook, always attach bind \u2014 it
+wires exposure tracking and goal listeners. <AdaptiveText> swaps dashboard-managed text.
 
 ## Rung 3 \u2014 Reorder (structure)
 
@@ -1856,6 +1879,23 @@ useLayoutOrder(). Non-React sites: sections: ['#hero', '#pricing', '#faq'] (CSS
 the theme's natural order) in window.sentient \u2014 the snippet reorders those elements within
 their shared parent, and applies nothing if any selector drifts.
 
+## No-code install order (snippet)
+
+Two tags in <head>, in this order: one inline <script> that assigns the window.sentient config
+and then, in the same tag after the ';', runs the inline pre-paint script; then the deferred
+loader. The pre-paint script reads window.sentient when it runs, so sharing the tag is safe. It
+is optional but recommended \u2014 the loader is deferred, so on a return visit the page can paint
+its original state before the loader runs; the inline script applies the last served decision
+from the visitor's own device first, with no network call and no cloak. Get the exact bytes from
+the dashboard's Install page, or from renderSnippetInstall({ config }) in
+'@sentientui/snippet/install' (renderSnippetPrePaintScript() for the script alone).
+
+Strict Content-Security-Policy (script hashes): use the three-tag form instead \u2014 config, the
+pre-paint script alone, then the loader (renderSnippetInstall({ config, split: true })). The
+combined tag contains the site's config, so its hash differs per site; the split pre-paint tag is
+byte-identical everywhere, so one hash covers it. Existing three-tag and config + loader installs
+keep working.
+
 ## Testing the integration
 
 Use '@sentientui/react/testing': renderWithSentient(ui, { variants, slots, persona }) forces
@@ -2017,8 +2057,182 @@ function registerAgentTrafficTools(server, client) {
   );
 }
 
+// src/tools/cells.ts
+import { z as z15 } from "zod";
+var personaOutput = z15.object({
+  key: z15.string(),
+  displayName: z15.string(),
+  description: z15.string().nullable(),
+  share: z15.number().describe("Fraction of 30-day decided sessions")
+});
+var cellOutput = z15.object({
+  slotId: z15.string(),
+  persona: z15.string(),
+  status: z15.string().describe("pending | generating | live | error | rejected"),
+  requestedBy: z15.string(),
+  armId: z15.string().nullable(),
+  rationale: z15.string().nullable(),
+  error: z15.string().nullable(),
+  updatedAt: z15.string(),
+  // These ride the API response too; omitting them from the schema made zod
+  // STRIP them, so agents could never see refinement or retry state.
+  refinedFrom: z15.string().nullable().optional().describe("Incumbent arm this cell is improving on \u2014 a pending cell with this set still SERVES the incumbent"),
+  notBefore: z15.string().nullable().optional().describe("ISO time the queue will next consider this cell (retry backoff / daily-cap deferral); null when due now"),
+  attempts: z15.number().optional().describe("Generation attempts so far"),
+  performance: z15.object({
+    shown: z15.number(),
+    conversions: z15.number(),
+    deltaPct: z15.number().nullable().describe("Signed % vs the original conversion rate"),
+    tier: z15.string().describe("early | no_baseline | winning | losing | flat")
+  }).optional().describe("Present on live cells (and, mid-refinement, the incumbent arm): the at-a-glance readout")
+});
+function registerCellTools(server, client) {
+  server.registerTool(
+    "get_cell_matrix",
+    {
+      title: "Persona \xD7 slot cell matrix",
+      description: 'The "Who sees what" matrix: which visitor types (personas) have an AI-generated version live in each personalizable region (slot), with per-persona traffic share and the first-miss auto-fill setting. A cell with no row means that visitor type sees the original.' + UNTRUSTED_FIELDS_NOTE,
+      inputSchema: { projectId: projectIdSchema },
+      outputSchema: {
+        slots: z15.array(
+          z15.object({
+            slotId: z15.string(),
+            displayName: z15.string(),
+            supportsForms: z15.boolean(),
+            // API sends this; without it zod stripped the draft-vs-live signal.
+            live: z15.boolean().optional().describe("False for an sdk-registered draft column \u2014 nothing serves until its first generation publishes it")
+          })
+        ),
+        personas: z15.array(personaOutput),
+        cells: z15.array(cellOutput),
+        autoFill: z15.boolean(),
+        personaSource: z15.string().describe("Active persona-set source: default | declared | discovered"),
+        undecidedShare: z15.number()
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false }
+    },
+    withApiErrorGuidance(async ({ projectId }) => {
+      const id = encodeURIComponent(projectId);
+      const data = await client.get(`/projects/${id}/cells`);
+      const byCell = new Map(data.cells.map((c) => [`${c.slotId}::${c.persona}`, c]));
+      const lines = [
+        `Slots: ${data.slots.map((s) => `${untrusted(s.displayName)}${s.live === false ? " [draft]" : ""}`).join(", ") || "(none published)"}`,
+        `Auto-fill on first miss: ${data.autoFill ? "ON" : "off"} \xB7 persona source: ${data.personaSource}`
+      ];
+      for (const p of data.personas) {
+        const states = data.slots.map((s) => {
+          const c = byCell.get(`${s.slotId}::${p.key}`);
+          let state = c ? c.status : "original";
+          if (c && (c.status === "pending" || c.status === "generating") && c.refinedFrom) {
+            state = `${c.status} (improving on ${untrusted(c.refinedFrom, 64)} \u2014 current version still live)`;
+          } else if (c && c.status === "pending" && c.notBefore && Date.parse(c.notBefore) > Date.now()) {
+            state = `pending (waiting until ${c.notBefore})`;
+          }
+          return `${untrusted(s.displayName, 40)}: ${state}`;
+        });
+        lines.push(`- ${untrusted(p.displayName)} (${Math.round(p.share * 100)}% of visitors) \u2014 ${states.join(" \xB7 ")}`);
+      }
+      lines.push(`Undecided visitors (${Math.round(data.undecidedShare * 100)}%) always see the original.`);
+      return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        structuredContent: data
+      };
+    })
+  );
+  server.registerTool(
+    "get_cell_detail",
+    {
+      title: "Cell story",
+      description: "One cell's full story: the generated option a visitor type sees in a slot, why it was written (the stored generation rationale), and how it is performing vs the original (deterministic plain-language verdict)." + UNTRUSTED_FIELDS_NOTE,
+      inputSchema: {
+        projectId: projectIdSchema,
+        slotId: z15.string().min(1).max(128).describe("The slot id (a matrix column)"),
+        persona: z15.string().min(1).max(64).describe("The persona key (a matrix row)")
+      },
+      outputSchema: {
+        cell: cellOutput.nullable(),
+        arm: z15.object({
+          id: z15.string(),
+          displayName: z15.string().nullable(),
+          content: z15.string().nullable(),
+          blocks: z15.unknown().nullable()
+        }).nullable(),
+        performance: z15.object({
+          shown: z15.number(),
+          conversions: z15.number(),
+          conversionRate: z15.number(),
+          baselineShown: z15.number(),
+          baselineConversions: z15.number(),
+          baselineConversionRate: z15.number()
+        }).nullable(),
+        verdict: z15.string()
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false }
+    },
+    withApiErrorGuidance(async ({ projectId, slotId, persona }) => {
+      var _a, _b, _c;
+      const id = encodeURIComponent(projectId);
+      const data = await client.get(`/projects/${id}/cells/detail?slotId=${encodeURIComponent(slotId)}&persona=${encodeURIComponent(persona)}`);
+      const lines = [];
+      if (data.arm) {
+        lines.push(
+          data.arm.content !== null ? `They see: "${untrusted(data.arm.content, 300)}"` : `They see a designed layout (option ${untrusted(data.arm.id, 64)}).`
+        );
+      } else {
+        lines.push("No generated version is live for this cell.");
+      }
+      if ((_a = data.cell) == null ? void 0 : _a.rationale) lines.push(`Why this exists: ${untrusted(data.cell.rationale, 500)}`);
+      if (((_b = data.cell) == null ? void 0 : _b.refinedFrom) && (data.cell.status === "pending" || data.cell.status === "generating")) {
+        lines.push(
+          `An improved take on ${untrusted(data.cell.refinedFrom, 64)} is being written \u2014 the current version keeps serving meanwhile.`
+        );
+      }
+      if ((_c = data.cell) == null ? void 0 : _c.error) lines.push(`Last attempt failed: ${untrusted(data.cell.error, 300)}`);
+      lines.push(data.verdict);
+      if (data.performance) {
+        lines.push(`Shown ${data.performance.shown} times, ${data.performance.conversions} conversions.`);
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        structuredContent: data
+      };
+    })
+  );
+  server.registerTool(
+    "generate_cell",
+    {
+      title: "Generate a cell version",
+      description: "Queue AI generation of a version for one (persona, slot) cell. The worker writes it asynchronously (usually under a minute), brand-locked, and it goes live as a named option the optimizer explores. Also works to regenerate or retry a failed cell. Requires a paid plan (anonymous demo tokens are read-only).",
+      inputSchema: {
+        projectId: projectIdSchema,
+        slotId: z15.string().min(1).max(128).describe("The slot id (a matrix column)"),
+        persona: z15.string().min(1).max(64).describe("The persona key (a matrix row)")
+      },
+      outputSchema: {
+        slotId: z15.string(),
+        persona: z15.string(),
+        status: z15.literal("pending").describe("Queued \u2014 check get_cell_matrix for progress")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    },
+    withApiErrorGuidance(async ({ projectId, slotId, persona }) => {
+      const id = encodeURIComponent(projectId);
+      await client.post(`/projects/${id}/cells/generate`, { slotId, persona });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Writing a version of ${untrusted(slotId, 64)} for ${untrusted(persona, 64)} \u2014 it usually goes live in under a minute. Check get_cell_matrix (status flips pending \u2192 live) or get_cell_detail for the story once it lands.`
+          }
+        ],
+        structuredContent: { slotId, persona, status: "pending" }
+      };
+    })
+  );
+}
+
 // src/server.ts
-var PKG_VERSION = true ? "0.17.7" : "0.0.0-dev";
+var PKG_VERSION = true ? "0.18.1" : "0.0.0-dev";
 function createMcpServer(client) {
   const server = new McpServer(
     {
@@ -2053,6 +2267,7 @@ function createMcpServer(client) {
   registerVariantWriteTools(server, client);
   registerIntegrationGuideTools(server);
   registerAgentTrafficTools(server, client);
+  registerCellTools(server, client);
   return server;
 }
 

package/dist/index.cjs

@@ -1795,8 +1795,9 @@ var import_zod13 = require("zod");
 var GUIDE = `# SentientUI integration guide \u2014 the adaptive ladder
 
 SentientUI adapts a site per visitor type (personas), learning from real conversions. Each
-project has its own persona vocabulary (dashboard -> Settings -> Personas; the default is
-buyer, researcher, deal_seeker, browser + unknown). Personas are inferred from behavior \u2014 or
+project has its own persona vocabulary (dashboard -> Settings -> Personas), and it starts
+EMPTY: every visitor is 'unknown' until a persona exists, and the optimizer learns across all
+traffic pooled in the meantime. Personas are DISCOVERED from behavior \u2014 or, far faster,
 DECLARED by the app when it already knows the visitor's role: init({ persona: 'admin' }) /
 <AdaptiveProvider persona=...> / window.sentient.persona. Declared beats inferred and serves
 at full confidence; unrecognized values are ignored server-side and surfaced in the dashboard
@@ -1813,8 +1814,9 @@ time.
    other React apps use <AdaptiveProvider> from '@sentientui/react') and add
    suppressHydrationWarning to <html> \u2014 an inline script sets persona attributes pre-paint.
    Nothing adapts and nothing is tracked until this wrap is in place.
-3. \`npm run dev\`, then open the app with \`?sentient_persona=buyer\` vs
-   \`?sentient_persona=deal_seeker\` to see it adapt. No API key needed (keyless local mode).
+3. \`npm run dev\`, then open the app with \`?sentient_persona=a\` vs
+   \`?sentient_persona=b\` to see it adapt \u2014 in keyless local mode any key drives the built-in
+   heuristic. No API key needed. Against a real project the key must be one you declared.
 4. To learn from real traffic: create a project at https://sentient-ui.com and set
    NEXT_PUBLIC_SENTIENT_API_KEY=pk_... in .env.local.
 
@@ -1823,8 +1825,8 @@ time.
 Persona attributes on <html> (zero declaration; the attribute carries the project's own
 vocabulary keys \u2014 declared or inferred):
 
-    html[data-sentient-persona='deal_seeker'] .discount-banner { display: block; }
-    html[data-sentient-confidence='low'] .discount-banner { display: none; }
+    html[data-sentient-persona='admin'] .admin-tools { display: block; }
+    html[data-sentient-confidence='low'] .admin-tools { display: none; }
 
 Learned style tokens (element-scoped, SSR-safe):
 
@@ -1839,14 +1841,35 @@ prefers-reduced-motion: reduce override in CSS.
 
 ## Rung 2 \u2014 Swap (alternate content)
 
+Generated versions (start here) \u2014 wrap what the page shows today; the children are the
+original:
+
+    <Adaptive id="hero-cta" goal="signup_click">
+      <a href="/signup">Start free trial</a>
+    </Adaptive>
+
+Mount + deploy registers the region. SentientUI writes versions per visitor type in the
+dashboard ("Who sees what") \u2014 no redeploy. The children render for holdout traffic, unknown
+visitor types, types with no version yet, and every error path. No server preload: mounted
+regions are requested in one batched call. First visit shows the original briefly, then swaps;
+return visits start from the last version. Keyless local mode renders originals only. Pass
+onFormSubmit to allow form versions; set reportBaselineText={false} on regions wrapping
+personalized or account content. (Formerly <AdaptiveSlot>.)
+
+Code variants \u2014 when you write the alternatives yourself:
+
+    <Adaptive id="buy-box" goal="buy_click"                      // goal REQUIRED
+      variants={{ control: <CalmBuyBox/>, urgent: <UrgentBuyBox/> }} />  // first key = baseline
+
+    // hook form:
     const { value, bind } = useAdaptive('buy-box', {
       variants: { calm: <CalmBuyBox/>, urgent: <UrgentBuyBox/> },  // first key = baseline
       goal: 'buy_click',                                            // REQUIRED
     });
     return <div {...bind}>{value}</div>;
 
-Always attach bind \u2014 it wires exposure tracking and goal listeners. <Adaptive> is the wrapper
-form; <AdaptiveText> swaps dashboard-managed text.
+Children or variants on one <Adaptive>, never both. With the hook, always attach bind \u2014 it
+wires exposure tracking and goal listeners. <AdaptiveText> swaps dashboard-managed text.
 
 ## Rung 3 \u2014 Reorder (structure)
 
@@ -1862,6 +1885,23 @@ useLayoutOrder(). Non-React sites: sections: ['#hero', '#pricing', '#faq'] (CSS
 the theme's natural order) in window.sentient \u2014 the snippet reorders those elements within
 their shared parent, and applies nothing if any selector drifts.
 
+## No-code install order (snippet)
+
+Two tags in <head>, in this order: one inline <script> that assigns the window.sentient config
+and then, in the same tag after the ';', runs the inline pre-paint script; then the deferred
+loader. The pre-paint script reads window.sentient when it runs, so sharing the tag is safe. It
+is optional but recommended \u2014 the loader is deferred, so on a return visit the page can paint
+its original state before the loader runs; the inline script applies the last served decision
+from the visitor's own device first, with no network call and no cloak. Get the exact bytes from
+the dashboard's Install page, or from renderSnippetInstall({ config }) in
+'@sentientui/snippet/install' (renderSnippetPrePaintScript() for the script alone).
+
+Strict Content-Security-Policy (script hashes): use the three-tag form instead \u2014 config, the
+pre-paint script alone, then the loader (renderSnippetInstall({ config, split: true })). The
+combined tag contains the site's config, so its hash differs per site; the split pre-paint tag is
+byte-identical everywhere, so one hash covers it. Existing three-tag and config + loader installs
+keep working.
+
 ## Testing the integration
 
 Use '@sentientui/react/testing': renderWithSentient(ui, { variants, slots, persona }) forces
@@ -2023,8 +2063,182 @@ function registerAgentTrafficTools(server, client) {
   );
 }
 
+// src/tools/cells.ts
+var import_zod15 = require("zod");
+var personaOutput = import_zod15.z.object({
+  key: import_zod15.z.string(),
+  displayName: import_zod15.z.string(),
+  description: import_zod15.z.string().nullable(),
+  share: import_zod15.z.number().describe("Fraction of 30-day decided sessions")
+});
+var cellOutput = import_zod15.z.object({
+  slotId: import_zod15.z.string(),
+  persona: import_zod15.z.string(),
+  status: import_zod15.z.string().describe("pending | generating | live | error | rejected"),
+  requestedBy: import_zod15.z.string(),
+  armId: import_zod15.z.string().nullable(),
+  rationale: import_zod15.z.string().nullable(),
+  error: import_zod15.z.string().nullable(),
+  updatedAt: import_zod15.z.string(),
+  // These ride the API response too; omitting them from the schema made zod
+  // STRIP them, so agents could never see refinement or retry state.
+  refinedFrom: import_zod15.z.string().nullable().optional().describe("Incumbent arm this cell is improving on \u2014 a pending cell with this set still SERVES the incumbent"),
+  notBefore: import_zod15.z.string().nullable().optional().describe("ISO time the queue will next consider this cell (retry backoff / daily-cap deferral); null when due now"),
+  attempts: import_zod15.z.number().optional().describe("Generation attempts so far"),
+  performance: import_zod15.z.object({
+    shown: import_zod15.z.number(),
+    conversions: import_zod15.z.number(),
+    deltaPct: import_zod15.z.number().nullable().describe("Signed % vs the original conversion rate"),
+    tier: import_zod15.z.string().describe("early | no_baseline | winning | losing | flat")
+  }).optional().describe("Present on live cells (and, mid-refinement, the incumbent arm): the at-a-glance readout")
+});
+function registerCellTools(server, client) {
+  server.registerTool(
+    "get_cell_matrix",
+    {
+      title: "Persona \xD7 slot cell matrix",
+      description: 'The "Who sees what" matrix: which visitor types (personas) have an AI-generated version live in each personalizable region (slot), with per-persona traffic share and the first-miss auto-fill setting. A cell with no row means that visitor type sees the original.' + UNTRUSTED_FIELDS_NOTE,
+      inputSchema: { projectId: projectIdSchema },
+      outputSchema: {
+        slots: import_zod15.z.array(
+          import_zod15.z.object({
+            slotId: import_zod15.z.string(),
+            displayName: import_zod15.z.string(),
+            supportsForms: import_zod15.z.boolean(),
+            // API sends this; without it zod stripped the draft-vs-live signal.
+            live: import_zod15.z.boolean().optional().describe("False for an sdk-registered draft column \u2014 nothing serves until its first generation publishes it")
+          })
+        ),
+        personas: import_zod15.z.array(personaOutput),
+        cells: import_zod15.z.array(cellOutput),
+        autoFill: import_zod15.z.boolean(),
+        personaSource: import_zod15.z.string().describe("Active persona-set source: default | declared | discovered"),
+        undecidedShare: import_zod15.z.number()
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false }
+    },
+    withApiErrorGuidance(async ({ projectId }) => {
+      const id = encodeURIComponent(projectId);
+      const data = await client.get(`/projects/${id}/cells`);
+      const byCell = new Map(data.cells.map((c) => [`${c.slotId}::${c.persona}`, c]));
+      const lines = [
+        `Slots: ${data.slots.map((s) => `${untrusted(s.displayName)}${s.live === false ? " [draft]" : ""}`).join(", ") || "(none published)"}`,
+        `Auto-fill on first miss: ${data.autoFill ? "ON" : "off"} \xB7 persona source: ${data.personaSource}`
+      ];
+      for (const p of data.personas) {
+        const states = data.slots.map((s) => {
+          const c = byCell.get(`${s.slotId}::${p.key}`);
+          let state = c ? c.status : "original";
+          if (c && (c.status === "pending" || c.status === "generating") && c.refinedFrom) {
+            state = `${c.status} (improving on ${untrusted(c.refinedFrom, 64)} \u2014 current version still live)`;
+          } else if (c && c.status === "pending" && c.notBefore && Date.parse(c.notBefore) > Date.now()) {
+            state = `pending (waiting until ${c.notBefore})`;
+          }
+          return `${untrusted(s.displayName, 40)}: ${state}`;
+        });
+        lines.push(`- ${untrusted(p.displayName)} (${Math.round(p.share * 100)}% of visitors) \u2014 ${states.join(" \xB7 ")}`);
+      }
+      lines.push(`Undecided visitors (${Math.round(data.undecidedShare * 100)}%) always see the original.`);
+      return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        structuredContent: data
+      };
+    })
+  );
+  server.registerTool(
+    "get_cell_detail",
+    {
+      title: "Cell story",
+      description: "One cell's full story: the generated option a visitor type sees in a slot, why it was written (the stored generation rationale), and how it is performing vs the original (deterministic plain-language verdict)." + UNTRUSTED_FIELDS_NOTE,
+      inputSchema: {
+        projectId: projectIdSchema,
+        slotId: import_zod15.z.string().min(1).max(128).describe("The slot id (a matrix column)"),
+        persona: import_zod15.z.string().min(1).max(64).describe("The persona key (a matrix row)")
+      },
+      outputSchema: {
+        cell: cellOutput.nullable(),
+        arm: import_zod15.z.object({
+          id: import_zod15.z.string(),
+          displayName: import_zod15.z.string().nullable(),
+          content: import_zod15.z.string().nullable(),
+          blocks: import_zod15.z.unknown().nullable()
+        }).nullable(),
+        performance: import_zod15.z.object({
+          shown: import_zod15.z.number(),
+          conversions: import_zod15.z.number(),
+          conversionRate: import_zod15.z.number(),
+          baselineShown: import_zod15.z.number(),
+          baselineConversions: import_zod15.z.number(),
+          baselineConversionRate: import_zod15.z.number()
+        }).nullable(),
+        verdict: import_zod15.z.string()
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false }
+    },
+    withApiErrorGuidance(async ({ projectId, slotId, persona }) => {
+      var _a2, _b, _c;
+      const id = encodeURIComponent(projectId);
+      const data = await client.get(`/projects/${id}/cells/detail?slotId=${encodeURIComponent(slotId)}&persona=${encodeURIComponent(persona)}`);
+      const lines = [];
+      if (data.arm) {
+        lines.push(
+          data.arm.content !== null ? `They see: "${untrusted(data.arm.content, 300)}"` : `They see a designed layout (option ${untrusted(data.arm.id, 64)}).`
+        );
+      } else {
+        lines.push("No generated version is live for this cell.");
+      }
+      if ((_a2 = data.cell) == null ? void 0 : _a2.rationale) lines.push(`Why this exists: ${untrusted(data.cell.rationale, 500)}`);
+      if (((_b = data.cell) == null ? void 0 : _b.refinedFrom) && (data.cell.status === "pending" || data.cell.status === "generating")) {
+        lines.push(
+          `An improved take on ${untrusted(data.cell.refinedFrom, 64)} is being written \u2014 the current version keeps serving meanwhile.`
+        );
+      }
+      if ((_c = data.cell) == null ? void 0 : _c.error) lines.push(`Last attempt failed: ${untrusted(data.cell.error, 300)}`);
+      lines.push(data.verdict);
+      if (data.performance) {
+        lines.push(`Shown ${data.performance.shown} times, ${data.performance.conversions} conversions.`);
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        structuredContent: data
+      };
+    })
+  );
+  server.registerTool(
+    "generate_cell",
+    {
+      title: "Generate a cell version",
+      description: "Queue AI generation of a version for one (persona, slot) cell. The worker writes it asynchronously (usually under a minute), brand-locked, and it goes live as a named option the optimizer explores. Also works to regenerate or retry a failed cell. Requires a paid plan (anonymous demo tokens are read-only).",
+      inputSchema: {
+        projectId: projectIdSchema,
+        slotId: import_zod15.z.string().min(1).max(128).describe("The slot id (a matrix column)"),
+        persona: import_zod15.z.string().min(1).max(64).describe("The persona key (a matrix row)")
+      },
+      outputSchema: {
+        slotId: import_zod15.z.string(),
+        persona: import_zod15.z.string(),
+        status: import_zod15.z.literal("pending").describe("Queued \u2014 check get_cell_matrix for progress")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    },
+    withApiErrorGuidance(async ({ projectId, slotId, persona }) => {
+      const id = encodeURIComponent(projectId);
+      await client.post(`/projects/${id}/cells/generate`, { slotId, persona });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Writing a version of ${untrusted(slotId, 64)} for ${untrusted(persona, 64)} \u2014 it usually goes live in under a minute. Check get_cell_matrix (status flips pending \u2192 live) or get_cell_detail for the story once it lands.`
+          }
+        ],
+        structuredContent: { slotId, persona, status: "pending" }
+      };
+    })
+  );
+}
+
 // src/server.ts
-var PKG_VERSION = true ? "0.17.7" : "0.0.0-dev";
+var PKG_VERSION = true ? "0.18.1" : "0.0.0-dev";
 function createMcpServer(client) {
   const server = new import_mcp.McpServer(
     {
@@ -2059,6 +2273,7 @@ function createMcpServer(client) {
   registerVariantWriteTools(server, client);
   registerIntegrationGuideTools(server);
   registerAgentTrafficTools(server, client);
+  registerCellTools(server, client);
   return server;
 }
 

package/dist/index.js

@@ -2,7 +2,7 @@
 import {
   ApiClient,
   createMcpServer
-} from "./chunk-5PR2LCNN.js";
+} from "./chunk-HEMPCGWX.js";
 
 // src/index.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

package/dist/lib.cjs

@@ -1819,8 +1819,9 @@ var import_zod13 = require("zod");
 var GUIDE = `# SentientUI integration guide \u2014 the adaptive ladder
 
 SentientUI adapts a site per visitor type (personas), learning from real conversions. Each
-project has its own persona vocabulary (dashboard -> Settings -> Personas; the default is
-buyer, researcher, deal_seeker, browser + unknown). Personas are inferred from behavior \u2014 or
+project has its own persona vocabulary (dashboard -> Settings -> Personas), and it starts
+EMPTY: every visitor is 'unknown' until a persona exists, and the optimizer learns across all
+traffic pooled in the meantime. Personas are DISCOVERED from behavior \u2014 or, far faster,
 DECLARED by the app when it already knows the visitor's role: init({ persona: 'admin' }) /
 <AdaptiveProvider persona=...> / window.sentient.persona. Declared beats inferred and serves
 at full confidence; unrecognized values are ignored server-side and surfaced in the dashboard
@@ -1837,8 +1838,9 @@ time.
    other React apps use <AdaptiveProvider> from '@sentientui/react') and add
    suppressHydrationWarning to <html> \u2014 an inline script sets persona attributes pre-paint.
    Nothing adapts and nothing is tracked until this wrap is in place.
-3. \`npm run dev\`, then open the app with \`?sentient_persona=buyer\` vs
-   \`?sentient_persona=deal_seeker\` to see it adapt. No API key needed (keyless local mode).
+3. \`npm run dev\`, then open the app with \`?sentient_persona=a\` vs
+   \`?sentient_persona=b\` to see it adapt \u2014 in keyless local mode any key drives the built-in
+   heuristic. No API key needed. Against a real project the key must be one you declared.
 4. To learn from real traffic: create a project at https://sentient-ui.com and set
    NEXT_PUBLIC_SENTIENT_API_KEY=pk_... in .env.local.
 
@@ -1847,8 +1849,8 @@ time.
 Persona attributes on <html> (zero declaration; the attribute carries the project's own
 vocabulary keys \u2014 declared or inferred):
 
-    html[data-sentient-persona='deal_seeker'] .discount-banner { display: block; }
-    html[data-sentient-confidence='low'] .discount-banner { display: none; }
+    html[data-sentient-persona='admin'] .admin-tools { display: block; }
+    html[data-sentient-confidence='low'] .admin-tools { display: none; }
 
 Learned style tokens (element-scoped, SSR-safe):
 
@@ -1863,14 +1865,35 @@ prefers-reduced-motion: reduce override in CSS.
 
 ## Rung 2 \u2014 Swap (alternate content)
 
+Generated versions (start here) \u2014 wrap what the page shows today; the children are the
+original:
+
+    <Adaptive id="hero-cta" goal="signup_click">
+      <a href="/signup">Start free trial</a>
+    </Adaptive>
+
+Mount + deploy registers the region. SentientUI writes versions per visitor type in the
+dashboard ("Who sees what") \u2014 no redeploy. The children render for holdout traffic, unknown
+visitor types, types with no version yet, and every error path. No server preload: mounted
+regions are requested in one batched call. First visit shows the original briefly, then swaps;
+return visits start from the last version. Keyless local mode renders originals only. Pass
+onFormSubmit to allow form versions; set reportBaselineText={false} on regions wrapping
+personalized or account content. (Formerly <AdaptiveSlot>.)
+
+Code variants \u2014 when you write the alternatives yourself:
+
+    <Adaptive id="buy-box" goal="buy_click"                      // goal REQUIRED
+      variants={{ control: <CalmBuyBox/>, urgent: <UrgentBuyBox/> }} />  // first key = baseline
+
+    // hook form:
     const { value, bind } = useAdaptive('buy-box', {
       variants: { calm: <CalmBuyBox/>, urgent: <UrgentBuyBox/> },  // first key = baseline
       goal: 'buy_click',                                            // REQUIRED
     });
     return <div {...bind}>{value}</div>;
 
-Always attach bind \u2014 it wires exposure tracking and goal listeners. <Adaptive> is the wrapper
-form; <AdaptiveText> swaps dashboard-managed text.
+Children or variants on one <Adaptive>, never both. With the hook, always attach bind \u2014 it
+wires exposure tracking and goal listeners. <AdaptiveText> swaps dashboard-managed text.
 
 ## Rung 3 \u2014 Reorder (structure)
 
@@ -1886,6 +1909,23 @@ useLayoutOrder(). Non-React sites: sections: ['#hero', '#pricing', '#faq'] (CSS
 the theme's natural order) in window.sentient \u2014 the snippet reorders those elements within
 their shared parent, and applies nothing if any selector drifts.
 
+## No-code install order (snippet)
+
+Two tags in <head>, in this order: one inline <script> that assigns the window.sentient config
+and then, in the same tag after the ';', runs the inline pre-paint script; then the deferred
+loader. The pre-paint script reads window.sentient when it runs, so sharing the tag is safe. It
+is optional but recommended \u2014 the loader is deferred, so on a return visit the page can paint
+its original state before the loader runs; the inline script applies the last served decision
+from the visitor's own device first, with no network call and no cloak. Get the exact bytes from
+the dashboard's Install page, or from renderSnippetInstall({ config }) in
+'@sentientui/snippet/install' (renderSnippetPrePaintScript() for the script alone).
+
+Strict Content-Security-Policy (script hashes): use the three-tag form instead \u2014 config, the
+pre-paint script alone, then the loader (renderSnippetInstall({ config, split: true })). The
+combined tag contains the site's config, so its hash differs per site; the split pre-paint tag is
+byte-identical everywhere, so one hash covers it. Existing three-tag and config + loader installs
+keep working.
+
 ## Testing the integration
 
 Use '@sentientui/react/testing': renderWithSentient(ui, { variants, slots, persona }) forces
@@ -2047,8 +2087,182 @@ function registerAgentTrafficTools(server, client) {
   );
 }
 
+// src/tools/cells.ts
+var import_zod15 = require("zod");
+var personaOutput = import_zod15.z.object({
+  key: import_zod15.z.string(),
+  displayName: import_zod15.z.string(),
+  description: import_zod15.z.string().nullable(),
+  share: import_zod15.z.number().describe("Fraction of 30-day decided sessions")
+});
+var cellOutput = import_zod15.z.object({
+  slotId: import_zod15.z.string(),
+  persona: import_zod15.z.string(),
+  status: import_zod15.z.string().describe("pending | generating | live | error | rejected"),
+  requestedBy: import_zod15.z.string(),
+  armId: import_zod15.z.string().nullable(),
+  rationale: import_zod15.z.string().nullable(),
+  error: import_zod15.z.string().nullable(),
+  updatedAt: import_zod15.z.string(),
+  // These ride the API response too; omitting them from the schema made zod
+  // STRIP them, so agents could never see refinement or retry state.
+  refinedFrom: import_zod15.z.string().nullable().optional().describe("Incumbent arm this cell is improving on \u2014 a pending cell with this set still SERVES the incumbent"),
+  notBefore: import_zod15.z.string().nullable().optional().describe("ISO time the queue will next consider this cell (retry backoff / daily-cap deferral); null when due now"),
+  attempts: import_zod15.z.number().optional().describe("Generation attempts so far"),
+  performance: import_zod15.z.object({
+    shown: import_zod15.z.number(),
+    conversions: import_zod15.z.number(),
+    deltaPct: import_zod15.z.number().nullable().describe("Signed % vs the original conversion rate"),
+    tier: import_zod15.z.string().describe("early | no_baseline | winning | losing | flat")
+  }).optional().describe("Present on live cells (and, mid-refinement, the incumbent arm): the at-a-glance readout")
+});
+function registerCellTools(server, client) {
+  server.registerTool(
+    "get_cell_matrix",
+    {
+      title: "Persona \xD7 slot cell matrix",
+      description: 'The "Who sees what" matrix: which visitor types (personas) have an AI-generated version live in each personalizable region (slot), with per-persona traffic share and the first-miss auto-fill setting. A cell with no row means that visitor type sees the original.' + UNTRUSTED_FIELDS_NOTE,
+      inputSchema: { projectId: projectIdSchema },
+      outputSchema: {
+        slots: import_zod15.z.array(
+          import_zod15.z.object({
+            slotId: import_zod15.z.string(),
+            displayName: import_zod15.z.string(),
+            supportsForms: import_zod15.z.boolean(),
+            // API sends this; without it zod stripped the draft-vs-live signal.
+            live: import_zod15.z.boolean().optional().describe("False for an sdk-registered draft column \u2014 nothing serves until its first generation publishes it")
+          })
+        ),
+        personas: import_zod15.z.array(personaOutput),
+        cells: import_zod15.z.array(cellOutput),
+        autoFill: import_zod15.z.boolean(),
+        personaSource: import_zod15.z.string().describe("Active persona-set source: default | declared | discovered"),
+        undecidedShare: import_zod15.z.number()
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false }
+    },
+    withApiErrorGuidance(async ({ projectId }) => {
+      const id = encodeURIComponent(projectId);
+      const data = await client.get(`/projects/${id}/cells`);
+      const byCell = new Map(data.cells.map((c) => [`${c.slotId}::${c.persona}`, c]));
+      const lines = [
+        `Slots: ${data.slots.map((s) => `${untrusted(s.displayName)}${s.live === false ? " [draft]" : ""}`).join(", ") || "(none published)"}`,
+        `Auto-fill on first miss: ${data.autoFill ? "ON" : "off"} \xB7 persona source: ${data.personaSource}`
+      ];
+      for (const p of data.personas) {
+        const states = data.slots.map((s) => {
+          const c = byCell.get(`${s.slotId}::${p.key}`);
+          let state = c ? c.status : "original";
+          if (c && (c.status === "pending" || c.status === "generating") && c.refinedFrom) {
+            state = `${c.status} (improving on ${untrusted(c.refinedFrom, 64)} \u2014 current version still live)`;
+          } else if (c && c.status === "pending" && c.notBefore && Date.parse(c.notBefore) > Date.now()) {
+            state = `pending (waiting until ${c.notBefore})`;
+          }
+          return `${untrusted(s.displayName, 40)}: ${state}`;
+        });
+        lines.push(`- ${untrusted(p.displayName)} (${Math.round(p.share * 100)}% of visitors) \u2014 ${states.join(" \xB7 ")}`);
+      }
+      lines.push(`Undecided visitors (${Math.round(data.undecidedShare * 100)}%) always see the original.`);
+      return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        structuredContent: data
+      };
+    })
+  );
+  server.registerTool(
+    "get_cell_detail",
+    {
+      title: "Cell story",
+      description: "One cell's full story: the generated option a visitor type sees in a slot, why it was written (the stored generation rationale), and how it is performing vs the original (deterministic plain-language verdict)." + UNTRUSTED_FIELDS_NOTE,
+      inputSchema: {
+        projectId: projectIdSchema,
+        slotId: import_zod15.z.string().min(1).max(128).describe("The slot id (a matrix column)"),
+        persona: import_zod15.z.string().min(1).max(64).describe("The persona key (a matrix row)")
+      },
+      outputSchema: {
+        cell: cellOutput.nullable(),
+        arm: import_zod15.z.object({
+          id: import_zod15.z.string(),
+          displayName: import_zod15.z.string().nullable(),
+          content: import_zod15.z.string().nullable(),
+          blocks: import_zod15.z.unknown().nullable()
+        }).nullable(),
+        performance: import_zod15.z.object({
+          shown: import_zod15.z.number(),
+          conversions: import_zod15.z.number(),
+          conversionRate: import_zod15.z.number(),
+          baselineShown: import_zod15.z.number(),
+          baselineConversions: import_zod15.z.number(),
+          baselineConversionRate: import_zod15.z.number()
+        }).nullable(),
+        verdict: import_zod15.z.string()
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false }
+    },
+    withApiErrorGuidance(async ({ projectId, slotId, persona }) => {
+      var _a, _b, _c;
+      const id = encodeURIComponent(projectId);
+      const data = await client.get(`/projects/${id}/cells/detail?slotId=${encodeURIComponent(slotId)}&persona=${encodeURIComponent(persona)}`);
+      const lines = [];
+      if (data.arm) {
+        lines.push(
+          data.arm.content !== null ? `They see: "${untrusted(data.arm.content, 300)}"` : `They see a designed layout (option ${untrusted(data.arm.id, 64)}).`
+        );
+      } else {
+        lines.push("No generated version is live for this cell.");
+      }
+      if ((_a = data.cell) == null ? void 0 : _a.rationale) lines.push(`Why this exists: ${untrusted(data.cell.rationale, 500)}`);
+      if (((_b = data.cell) == null ? void 0 : _b.refinedFrom) && (data.cell.status === "pending" || data.cell.status === "generating")) {
+        lines.push(
+          `An improved take on ${untrusted(data.cell.refinedFrom, 64)} is being written \u2014 the current version keeps serving meanwhile.`
+        );
+      }
+      if ((_c = data.cell) == null ? void 0 : _c.error) lines.push(`Last attempt failed: ${untrusted(data.cell.error, 300)}`);
+      lines.push(data.verdict);
+      if (data.performance) {
+        lines.push(`Shown ${data.performance.shown} times, ${data.performance.conversions} conversions.`);
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        structuredContent: data
+      };
+    })
+  );
+  server.registerTool(
+    "generate_cell",
+    {
+      title: "Generate a cell version",
+      description: "Queue AI generation of a version for one (persona, slot) cell. The worker writes it asynchronously (usually under a minute), brand-locked, and it goes live as a named option the optimizer explores. Also works to regenerate or retry a failed cell. Requires a paid plan (anonymous demo tokens are read-only).",
+      inputSchema: {
+        projectId: projectIdSchema,
+        slotId: import_zod15.z.string().min(1).max(128).describe("The slot id (a matrix column)"),
+        persona: import_zod15.z.string().min(1).max(64).describe("The persona key (a matrix row)")
+      },
+      outputSchema: {
+        slotId: import_zod15.z.string(),
+        persona: import_zod15.z.string(),
+        status: import_zod15.z.literal("pending").describe("Queued \u2014 check get_cell_matrix for progress")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    },
+    withApiErrorGuidance(async ({ projectId, slotId, persona }) => {
+      const id = encodeURIComponent(projectId);
+      await client.post(`/projects/${id}/cells/generate`, { slotId, persona });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Writing a version of ${untrusted(slotId, 64)} for ${untrusted(persona, 64)} \u2014 it usually goes live in under a minute. Check get_cell_matrix (status flips pending \u2192 live) or get_cell_detail for the story once it lands.`
+          }
+        ],
+        structuredContent: { slotId, persona, status: "pending" }
+      };
+    })
+  );
+}
+
 // src/server.ts
-var PKG_VERSION = true ? "0.17.7" : "0.0.0-dev";
+var PKG_VERSION = true ? "0.18.1" : "0.0.0-dev";
 function createMcpServer(client) {
   const server = new import_mcp.McpServer(
     {
@@ -2083,6 +2297,7 @@ function createMcpServer(client) {
   registerVariantWriteTools(server, client);
   registerIntegrationGuideTools(server);
   registerAgentTrafficTools(server, client);
+  registerCellTools(server, client);
   return server;
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/lib.js

@@ -4,7 +4,7 @@ import {
   ApiError,
   PUBLIC_UI_RESOURCE_URIS,
   createMcpServer
-} from "./chunk-5PR2LCNN.js";
+} from "./chunk-HEMPCGWX.js";
 export {
   ApiClient,
   ApiError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentientui/mcp",
-  "version": "0.17.7",
+  "version": "0.18.1",
   "description": "MCP server for SentientUI — exposes project data and actions to AI agents",
   "license": "MIT",
   "homepage": "https://sentient-ui.com",