@capivv/mcp-server 0.1.3 → 0.2.0

package/dist/tools/api-key-usage.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerApiKeyUsageTool(server: McpServer, client: CapivvClient): void;

package/dist/tools/api-key-usage.js

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+// V7 Phase C.5 — AI-callable SDK usage telemetry.
+//
+// Same backend endpoint the dashboard Usage dialog uses
+// (/dashboard/settings/api-keys/:id/usage). The MCP surface exists because
+// "is this key compromised?" is a question AI assistants are often asked —
+// they can fetch the data, render it inline, and compare against the
+// anomaly-detection rules documented in the runbook without the user
+// context-switching to the dashboard.
+export function registerApiKeyUsageTool(server, client) {
+    server.tool('capivv_api_key_usage', `Fetch request-level telemetry for a specific publishable API key (pk_live_* / pk_test_*). Returns hourly buckets of request counts, error counts, distinct IPs, SDK versions, and country codes — the same data the dashboard's Usage tab renders. Use this to investigate a suspected key leak: look for sudden IP spread, unexpected country codes, or rate spikes vs. a prior baseline.`, {
+        api_key_id: z
+            .string()
+            .describe('The api_keys.id of the key to inspect (UUID). Use capivv_whoami to see available apps — key IDs appear under each app in the dashboard Settings → Developer page.'),
+        hours: z
+            .number()
+            .int()
+            .min(1)
+            .max(168)
+            .optional()
+            .describe('Window in hours to summarize over (default 24, max 168 = 7 days).'),
+    }, async ({ api_key_id, hours }) => {
+        const usage = await client.getApiKeyUsage(api_key_id, hours ?? 24);
+        const lines = [];
+        lines.push(`Usage for key ${api_key_id.slice(0, 8)}… over the last ${usage.hours} hour(s):`);
+        lines.push('');
+        lines.push(`  Requests:        ${usage.summary.total_requests.toLocaleString()}`);
+        lines.push(`  Errors:          ${usage.summary.total_errors.toLocaleString()}`);
+        lines.push(`  Unique IPs:      ${usage.summary.distinct_ips}`);
+        lines.push(`  Countries:       ${usage.summary.distinct_countries}`);
+        lines.push(`  SDK versions:    ${usage.summary.distinct_sdk_versions}`);
+        lines.push('');
+        // Anomaly signals inline — surface the same ones the hourly scanner
+        // checks in capivv-workers::api_key_anomaly. AI assistant can quote
+        // these directly when answering "is this key compromised?"
+        const signals = [];
+        if (usage.summary.distinct_ips >= 5) {
+            signals.push(`  • ${usage.summary.distinct_ips} distinct IPs is high for a single app — investigate if this is expected.`);
+        }
+        if (usage.summary.distinct_countries >= 3) {
+            signals.push(`  • Traffic from ${usage.summary.distinct_countries} countries. If your app isn't multi-region, consider revoking.`);
+        }
+        if (usage.summary.total_requests > 10_000 && usage.hours <= 24) {
+            signals.push(`  • ${usage.summary.total_requests.toLocaleString()} requests in ${usage.hours}h crosses the 10k/hour absolute-volume threshold.`);
+        }
+        if (signals.length > 0) {
+            lines.push('Anomaly signals:');
+            lines.push(...signals);
+            lines.push('');
+        }
+        if (usage.samples.length === 0) {
+            lines.push('No traffic recorded in the selected window.');
+        }
+        else {
+            lines.push(`Sample buckets (showing up to 10 of ${usage.samples.length}):`);
+            for (const s of usage.samples.slice(0, 10)) {
+                const ip = s.client_ip ?? 'unknown';
+                const sdk = s.sdk_version ?? 'unknown';
+                const country = s.country_code ?? '??';
+                lines.push(`  ${s.bucket_start}  ${s.request_count}req/${s.error_count}err  ${ip}  ${sdk}  ${country}`);
+            }
+        }
+        return {
+            content: [
+                { type: 'text', text: lines.join('\n') },
+                { type: 'text', text: JSON.stringify(usage, null, 2) },
+            ],
+        };
+    });
+}

package/dist/tools/apply-rule.js

@@ -1,33 +1,74 @@
 import { z } from 'zod';
+import YAML from 'yaml';
 export function registerApplyRuleTool(server, client) {
-    server.tool('capivv_apply_rule', 'Apply a YAML rule configuration. Validates the rule first, then creates or updates it. Returns validation errors if the YAML is invalid.', {
-        name: z.string().describe('Rule name'),
-        content: z.string().describe('YAML rule content'),
+    server.tool('capivv_apply_rule', `Apply a YAML rule configuration. Validates the rule first, then creates or updates it.
+
+Example YAML:
+  conditions:
+    - type: never_subscribed
+  actions:
+    - type: grant_entitlement
+      identifier: "trial_access"
+      expires_in_days: 7
+      reason: "New user trial"
+
+Condition types: audience, attribute, date_range, percentage, has_entitlement, has_product, subscription_status, renewal_window, is_trial_period, never_subscribed, churned_subscriber, country, platform, app_version
+Action types: override_price, discount_percent, discount_fixed, grant_entitlement, set_paywall, show_offering, cancel_offer, track_event, set_attribute`, {
+        name: z.string().describe('Rule name (used as both identifier and display name)'),
+        content: z.string().describe('YAML rule content with conditions and actions arrays'),
         priority: z.number().optional().default(100).describe('Rule priority (lower = higher priority)'),
         is_enabled: z.boolean().optional().default(true).describe('Whether the rule is active'),
     }, async ({ name, content, priority, is_enabled }) => {
+        // Parse YAML to extract conditions, actions, guardrails
+        let parsed;
+        try {
+            parsed = YAML.parse(content);
+            if (!parsed || typeof parsed !== 'object') {
+                throw new Error('YAML must be an object with conditions and/or actions');
+            }
+        }
+        catch (e) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            success: false,
+                            error: `Invalid YAML: ${e instanceof Error ? e.message : String(e)}`,
+                        }, null, 2) }],
+                isError: true,
+            };
+        }
+        const conditions = parsed.conditions ?? [];
+        const actions = parsed.actions ?? [];
+        const guardrails = parsed.guardrails;
         // Validate first
-        const validation = await client.validateRule(content);
+        const validation = await client.validateRule({ conditions, actions, guardrails });
         if (!validation.is_valid) {
-            const result = {
-                success: false,
-                validation_errors: validation.errors,
-                validation_warnings: validation.warnings,
-            };
             return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                content: [{ type: 'text', text: JSON.stringify({
+                            success: false,
+                            validation_errors: validation.errors,
+                            validation_warnings: validation.warnings,
+                        }, null, 2) }],
                 isError: true,
             };
         }
-        // Create/update the rule
-        const rule = await client.upsertRule({ name, content, priority, is_enabled });
+        // Create the rule
+        const identifier = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+        const rule = await client.createRule({
+            identifier,
+            name,
+            conditions,
+            actions,
+            guardrails,
+            priority,
+        });
         const result = {
             success: true,
             rule: {
                 id: rule.id,
+                identifier: rule.identifier,
                 name: rule.name,
                 priority: rule.priority,
-                is_enabled: rule.is_enabled,
+                status: rule.status,
                 updated_at: rule.updated_at,
             },
             validation_warnings: validation.warnings.length > 0 ? validation.warnings : undefined,

package/dist/tools/autopilot-status.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerAutopilotStatusTool(server: McpServer, client: CapivvClient): void;

package/dist/tools/autopilot-status.js

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+// V7 B.5 — capivv_autopilot_status
+//
+// Answers "show me everything autopilot did for this app" from one MCP call.
+// Composed from the existing listOfferings / listRules / listExperiments
+// client methods plus the listApps lookup to resolve the app name — no new
+// backend endpoint. Paywalls + rescue flows + promotions live in the same
+// autopilot provenance story but don't have MCP list methods today; the tool
+// surfaces a link to the dashboard pages where those badges also render.
+export function registerAutopilotStatusTool(server, client) {
+    server.tool('capivv_autopilot_status', `Show everything autopilot generated for a specific app — offerings, entitlement rules, and experiments, filtered by the generated_by provenance marker. Useful right after capivv_setup_wizard or import-apps to confirm what was auto-created, or when a user asks "what did autopilot do for app X?"`, {
+        app_id: z
+            .string()
+            .describe('The Capivv app ID to inspect. Use capivv_list_apps to find it, or capivv_whoami to see all apps reachable from your API key.'),
+    }, async ({ app_id }) => {
+        const [apps, offerings, rules, experiments] = await Promise.all([
+            client.listApps(),
+            client.listOfferings(),
+            client.listRules(),
+            client.listExperiments(),
+        ]);
+        const app = apps.find((a) => a.id === app_id);
+        if (!app) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `No app found with id ${app_id}. Available apps: ${apps.map((a) => `${a.name} (${a.id})`).join(', ') || 'none'}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // generated_by uses an `autopilot_v` prefix across versions. Matching
+        // on the prefix lets the tool show v1 + v2 resources without hard-
+        // coding version strings that'll drift.
+        const autopilotStamp = (gb) => typeof gb === 'string' && gb.startsWith('autopilot_');
+        const autopilotOfferings = offerings.filter((o) => o.app_id === app_id && autopilotStamp(o.generated_by));
+        const autopilotRules = rules.filter((r) => {
+            if (!autopilotStamp(r.generated_by))
+                return false;
+            // Rules are tenant-scoped; we tagged the source app_id in metadata.
+            const md = r.metadata;
+            return md?.generated_for_app_id === app_id;
+        });
+        const autopilotExperiments = experiments.filter((e) => {
+            if (!autopilotStamp(e.generated_by))
+                return false;
+            const md = e.metadata;
+            return md?.generated_for_app_id === app_id;
+        });
+        const totals = {
+            offerings: autopilotOfferings.length,
+            rules: autopilotRules.length,
+            experiments: autopilotExperiments.length,
+        };
+        const nothing = totals.offerings + totals.rules + totals.experiments === 0;
+        const lines = [];
+        lines.push(`Autopilot status for ${app.name} (${app.bundle_id ?? app_id})`);
+        lines.push('');
+        if (nothing) {
+            lines.push("No autopilot-generated resources for this app (yet). If you just ran capivv_setup_wizard or imported products, try again — autopilot runs inline during import.");
+        }
+        else {
+            lines.push(`Summary: ${totals.offerings} offering, ${totals.rules} rule(s), ${totals.experiments} experiment(s).`);
+            lines.push('');
+            if (autopilotOfferings.length > 0) {
+                lines.push('Offerings:');
+                for (const o of autopilotOfferings) {
+                    lines.push(`  • ${o.identifier} — ${o.display_name} [${o.generated_by}]`);
+                }
+            }
+            if (autopilotRules.length > 0) {
+                lines.push('Rules:');
+                for (const r of autopilotRules) {
+                    lines.push(`  • ${r.identifier} — ${r.name} [${r.generated_by}]`);
+                }
+            }
+            if (autopilotExperiments.length > 0) {
+                lines.push('Experiments:');
+                for (const e of autopilotExperiments) {
+                    lines.push(`  • ${e.name} — status: ${e.status} [${e.generated_by}]`);
+                }
+            }
+            lines.push('');
+            lines.push('Paywalls + rescue flows + promotions also carry the "Autopilot" badge — open /paywalls, /rescue, /promotions in the dashboard to see them there.');
+        }
+        return {
+            content: [
+                { type: 'text', text: lines.join('\n') },
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        app: { id: app_id, name: app.name, bundle_id: app.bundle_id },
+                        totals,
+                        offerings: autopilotOfferings.map((o) => ({
+                            id: o.id,
+                            identifier: o.identifier,
+                            generated_by: o.generated_by,
+                        })),
+                        rules: autopilotRules.map((r) => ({
+                            id: r.id,
+                            identifier: r.identifier,
+                            generated_by: r.generated_by,
+                        })),
+                        experiments: autopilotExperiments.map((e) => ({
+                            id: e.id,
+                            name: e.name,
+                            status: e.status,
+                            generated_by: e.generated_by,
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+}

package/dist/tools/create-app.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerCreateAppTool(server: McpServer, client: CapivvClient): void;

package/dist/tools/create-app.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export function registerCreateAppTool(server, client) {
+    server.tool('capivv_create_app', 'Create a new app in Capivv with an explicit bundle ID. Prefer the dashboard\'s store-connect flow (which imports apps with real bundle IDs automatically); this tool is the manual fallback for web apps or apps without a store presence.', {
+        name: z.string().describe('App name (e.g., "My App")'),
+        platform: z.string().describe('Platform: ios, android, or web'),
+        bundle_id: z
+            .string()
+            .describe('Bundle identifier. Use your real reverse-DNS ID (e.g., "com.yourcompany.yourapp") — do NOT use com.example.myapp or other placeholder values.'),
+    }, async (args) => {
+        const app = await client.createApp(args);
+        return { content: [{ type: 'text', text: JSON.stringify(app, null, 2) }] };
+    });
+}

package/dist/tools/create-entitlement.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerCreateEntitlementTool(server: McpServer, client: CapivvClient): void;

package/dist/tools/create-entitlement.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export function registerCreateEntitlementTool(server, client) {
+    server.tool('capivv_create_entitlement', 'Create a new entitlement (feature access identifier). Products grant entitlements to users upon purchase.', {
+        identifier: z.string().describe('Unique identifier (e.g., "premium", "pro_features")'),
+        display_name: z.string().describe('Human-readable name (e.g., "Premium Access")'),
+        description: z.string().optional().describe('Optional description of what this entitlement unlocks'),
+    }, async (args) => {
+        const entitlement = await client.createEntitlement(args);
+        return { content: [{ type: 'text', text: JSON.stringify(entitlement, null, 2) }] };
+    });
+}

package/dist/tools/create-product.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerCreateProductTool(server: McpServer, client: CapivvClient): void;

package/dist/tools/create-product.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export function registerCreateProductTool(server, client) {
+    server.tool('capivv_create_product', [
+        'Create a Capivv-side product record (subscription, consumable, or non-consumable).',
+        'Sets pricing, subscription config, and entitlement links in one call.',
+        '',
+        'IMPORTANT: this creates the record inside Capivv only. Capivv does not write to App Store Connect or Google Play.',
+        'For purchases to validate, a product with the SAME `external_id` must also exist in App Store Connect (and/or Google Play) at the same price you set here.',
+        'Typical flow: create or confirm the product in App Store Connect at $X.XX, then call this tool with `external_id` matching the App Store Connect product ID.',
+        'Skip-to-import path: if products already exist in App Store Connect and your tenant has store credentials connected, use capivv_import_products instead — it pulls them in automatically.',
+    ].join(' '), {
+        app_id: z.string().describe('App ID this product belongs to'),
+        external_id: z.string().describe('Store product ID (e.g., "com.example.pro_monthly")'),
+        product_type: z.string().describe('One of: subscription, consumable, non_consumable'),
+        display_name: z.string().describe('Human-readable product name'),
+        description: z.string().optional().describe('Optional product description'),
+        entitlement_ids: z
+            .array(z.string())
+            .optional()
+            .describe('Entitlement IDs this product grants upon purchase'),
+        subscription: z
+            .object({
+            billing_period: z
+                .string()
+                .describe('Billing period: week, month, three_months, six_months, or year'),
+            grace_period_enabled: z.boolean().optional().describe('Enable grace period for failed renewals'),
+        })
+            .optional()
+            .describe('Subscription configuration (required for subscription products)'),
+        prices: z
+            .array(z.object({
+            currency: z.string().describe('ISO 4217 currency code (e.g., "USD")'),
+            amount_cents: z.number().describe('Price in cents (e.g., 1099 for $10.99)'),
+            is_default: z.boolean().optional().describe('Whether this is the default price'),
+        }))
+            .optional()
+            .describe('Product prices'),
+    }, async (args) => {
+        const product = await client.createProduct(args);
+        return { content: [{ type: 'text', text: JSON.stringify(product, null, 2) }] };
+    });
+}

package/dist/tools/delete-product.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerDeleteProductTool(server: McpServer, client: CapivvClient): void;

package/dist/tools/delete-product.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export function registerDeleteProductTool(server, client) {
+    server.tool('capivv_delete_product', 'Delete a product by ID. This is irreversible.', {
+        product_id: z.string().describe('Product ID to delete'),
+    }, async ({ product_id }) => {
+        await client.deleteProduct(product_id);
+        return { content: [{ type: 'text', text: `Product ${product_id} deleted.` }] };
+    });
+}

package/dist/tools/delete-rule.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerDeleteRuleTool(server: McpServer, client: CapivvClient): void;

package/dist/tools/delete-rule.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export function registerDeleteRuleTool(server, client) {
+    server.tool('capivv_delete_rule', 'Delete a business rule by ID. This is irreversible.', {
+        rule_id: z.string().describe('Rule ID to delete'),
+    }, async ({ rule_id }) => {
+        await client.deleteRule(rule_id);
+        return { content: [{ type: 'text', text: `Rule ${rule_id} deleted.` }] };
+    });
+}

package/dist/tools/import-products.js

@@ -1,17 +1,19 @@
 import { z } from 'zod';
 export function registerImportProductsTool(server, client) {
     server.tool('capivv_import_products', 'Import products from connected App Store Connect or Google Play Console into Capivv. Returns a preview of what will be imported including suggested products, entitlements, and offerings.', { app_id: z.string().describe('App ID to import products for') }, async ({ app_id }) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const preview = await client.getImportPreview(app_id);
-        const newProducts = preview.suggestion.products.filter((p) => !p.already_exists);
-        const newEntitlements = preview.suggestion.entitlements.filter((e) => !e.already_exists);
+        const suggestion = preview.suggestion ?? {};
+        const newProducts = (suggestion.products ?? []).filter((p) => !p.already_exists);
+        const newEntitlements = (suggestion.entitlements ?? []).filter((e) => !e.already_exists);
         const summary = {
             new_products: newProducts.length,
             new_entitlements: newEntitlements.length,
-            new_offerings: preview.suggestion.offerings.length,
+            new_offerings: (suggestion.offerings ?? []).length,
             existing_counts: preview.existing_counts,
-            warnings: preview.suggestion.warnings,
+            warnings: suggestion.warnings,
             store_errors: preview.store_errors,
-            details: preview.suggestion,
+            details: suggestion,
         };
         return { content: [{ type: 'text', text: JSON.stringify(summary, null, 2) }] };
     });

package/dist/tools/index.js

@@ -1,22 +1,61 @@
 import { registerStatusTool } from './status.js';
 import { registerListAppsTool } from './list-apps.js';
+import { registerCreateAppTool } from './create-app.js';
+import { registerListEntitlementsTool } from './list-entitlements.js';
+import { registerCreateEntitlementTool } from './create-entitlement.js';
 import { registerListProductsTool } from './list-products.js';
+import { registerCreateProductTool } from './create-product.js';
+import { registerUpdateProductTool } from './update-product.js';
+import { registerDeleteProductTool } from './delete-product.js';
 import { registerImportProductsTool } from './import-products.js';
 import { registerListOfferingsTool } from './list-offerings.js';
 import { registerCreateOfferingTool } from './create-offering.js';
 import { registerListRulesTool } from './list-rules.js';
 import { registerApplyRuleTool } from './apply-rule.js';
+import { registerActivateRuleTool } from './activate-rule.js';
+import { registerDeleteRuleTool } from './delete-rule.js';
 import { registerListExperimentsTool } from './list-experiments.js';
 import { registerGetAnalyticsTool } from './get-analytics.js';
+import { registerNextStepTool } from './next-step.js';
+import { registerSetupWizardTool } from './setup-wizard.js';
+import { registerVerifySetupTool } from './verify-setup.js';
+import { registerWhoamiTool } from './whoami.js';
+import { registerAutopilotStatusTool } from './autopilot-status.js';
+import { registerApiKeyUsageTool } from './api-key-usage.js';
 export function registerAllTools(server, client) {
+    // Identity — call this first to verify which workspace you're connected to
+    registerWhoamiTool(server, client);
+    // Autopilot diagnostics — what did autopilot do for a given app?
+    registerAutopilotStatusTool(server, client);
+    // SDK telemetry — investigate suspected key leaks inline.
+    registerApiKeyUsageTool(server, client);
+    // Onboarding & guidance
+    registerNextStepTool(server, client);
+    registerSetupWizardTool(server, client);
+    registerVerifySetupTool(server, client);
+    // Status & analytics
     registerStatusTool(server, client);
+    registerGetAnalyticsTool(server, client);
+    // Apps
     registerListAppsTool(server, client);
+    registerCreateAppTool(server, client);
+    // Entitlements
+    registerListEntitlementsTool(server, client);
+    registerCreateEntitlementTool(server, client);
+    // Products
     registerListProductsTool(server, client);
+    registerCreateProductTool(server, client);
+    registerUpdateProductTool(server, client);
+    registerDeleteProductTool(server, client);
     registerImportProductsTool(server, client);
+    // Offerings
     registerListOfferingsTool(server, client);
     registerCreateOfferingTool(server, client);
+    // Rules
     registerListRulesTool(server, client);
     registerApplyRuleTool(server, client);
+    registerActivateRuleTool(server, client);
+    registerDeleteRuleTool(server, client);
+    // Experiments
     registerListExperimentsTool(server, client);
-    registerGetAnalyticsTool(server, client);
 }

package/dist/tools/list-entitlements.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerListEntitlementsTool(server: McpServer, client: CapivvClient): void;

package/dist/tools/list-entitlements.js

@@ -0,0 +1,6 @@
+export function registerListEntitlementsTool(server, client) {
+    server.tool('capivv_list_entitlements', 'List all entitlements (feature access identifiers) configured in your Capivv account.', async () => {
+        const entitlements = await client.listEntitlements();
+        return { content: [{ type: 'text', text: JSON.stringify(entitlements, null, 2) }] };
+    });
+}

package/dist/tools/list-rules.js

@@ -1,11 +1,13 @@
 export function registerListRulesTool(server, client) {
-    server.tool('capivv_list_rules', 'List all YAML-based business rules with their status, priority, and last update time.', async () => {
+    server.tool('capivv_list_rules', 'List all business rules with their status, priority, and last update time.', async () => {
         const rules = await client.listRules();
         const summary = rules.map((r) => ({
             id: r.id,
+            identifier: r.identifier,
             name: r.name,
             priority: r.priority,
-            is_enabled: r.is_enabled,
+            status: r.status,
+            version: r.version,
             updated_at: r.updated_at,
         }));
         return { content: [{ type: 'text', text: JSON.stringify(summary, null, 2) }] };

package/dist/tools/next-step.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerNextStepTool(server: McpServer, client: CapivvClient): void;