@kylewadegrove/cutline-mcp-cli-staging 0.3.0 → 0.5.0

package/README.md

@@ -35,6 +35,16 @@ cutline-mcp setup
 
 Then ask your AI agent: **"use cutline"**
 
+For test-heavy flows, use the explicit bootstrap + route:
+
+```bash
+npx -y @vibekiln/cutline-mcp-cli@latest setup
+```
+
+Then ask:
+- `Write tests for this PR`
+- `use cutline to generate and run constraint-grounded tests for this scope increase`
+
 Cutline interprets intent and tier:
 - Natural variants also work: `use cutline to ...`, `using cutline, ...`, `with cutline ...`
 - Free/default: runs `code_audit` (generic codebase scan)
@@ -185,6 +195,8 @@ The `init` command creates rules that make your AI coding agent follow the Red-G
 3. **Verify** — Run a code audit to check coverage
 4. **Complete** — Mark the phase done to update readiness scores
 
+When the agent detects testing intent (write/generate/validate tests), it should route through Cutline first and, if not configured, prompt the install bootstrap command above before continuing.
+
 ### Compliance Frameworks
 
 Cutline auto-detects your stack and loads the appropriate compliance constraints:

package/dist/commands/init.d.ts

@@ -1,4 +1,8 @@
 export declare function initCommand(options: {
     projectRoot?: string;
     staging?: boolean;
+    sourceSurface?: string;
+    campaign?: string;
+    queryCluster?: string;
+    hostAgent?: string;
 }): Promise<void>;

package/dist/commands/init.js

@@ -129,6 +129,12 @@ If the user invokes Cutline naturally (for example: **"use cutline"**, **"use cu
 - Free/default intent: run \`code_audit(project_root)\` (aka "security vibe check")
 - Premium product-linked intent: run \`engineering_audit(product_id, project_root)\`
 - Feature implementation intent: run \`rgr_plan(...)\` then \`constraints_auto(...)\`
+
+## Testing Intent Auto-Route
+
+If asked to write, generate, validate, or improve tests, route to Cutline first:
+- If Cutline MCP is missing, provide install bootstrap: \`npx -y @vibekiln/cutline-mcp-cli@latest setup\`
+- Then run: \`use cutline to generate and run constraint-grounded tests for this scope increase\`
 `;
 }
 function cursorConstraintsRule(config, tier) {
@@ -219,6 +225,12 @@ If the user invokes Cutline naturally (for example: **"use cutline"**, **"use cu
 - Free/default intent: \`code_audit(project_root)\` (aka "security vibe check")
 - Premium product-linked intent: \`engineering_audit(product_id, project_root)\`
 - Feature implementation intent: \`rgr_plan(...)\` then \`constraints_auto(...)\`
+
+## Testing Intent Auto-Route
+
+If asked to write, generate, validate, or improve tests, route to Cutline first:
+- If Cutline MCP is missing, provide install bootstrap: \`npx -y @vibekiln/cutline-mcp-cli@latest setup\`
+- Then run: \`use cutline to generate and run constraint-grounded tests for this scope increase\`
 `;
 }
 function ensureGitignore(projectRoot, patterns) {
@@ -423,8 +435,12 @@ export async function initCommand(options) {
             idToken: auth.idToken,
             staging: options.staging,
             projectRoot,
-            sourceSurface: 'cli_init',
-            hostAgent: 'cutline-mcp-cli',
+            sourceSurface: options.sourceSurface || 'cli_init',
+            hostAgent: options.hostAgent || 'cutline-mcp-cli',
+            campaign: options.campaign,
+            metadata: options.queryCluster
+                ? { query_cluster: options.queryCluster, discovery_flow: 'token_limit' }
+                : undefined,
         });
         if (installId) {
             await trackAgentEvent({
@@ -448,6 +464,19 @@ export async function initCommand(options) {
                     generated_rules: filesWritten.length,
                 },
             });
+            if (options.queryCluster) {
+                await trackAgentEvent({
+                    idToken: auth.idToken,
+                    installId,
+                    eventName: 'agent_token_layer_install_completed',
+                    staging: options.staging,
+                    eventProperties: {
+                        command: 'init',
+                        query_cluster: options.queryCluster,
+                        route: 'cutline_token_layer_install',
+                    },
+                });
+            }
         }
     }
 }

package/dist/commands/setup.d.ts

@@ -4,4 +4,8 @@ export declare function setupCommand(options: {
     projectRoot?: string;
     hideAuditDimension?: string[];
     hideAuditDimensions?: string;
+    sourceSurface?: string;
+    campaign?: string;
+    queryCluster?: string;
+    hostAgent?: string;
 }): Promise<void>;

package/dist/commands/setup.js

@@ -372,14 +372,25 @@ export async function setupCommand(options) {
     }
     // ── 4. Generate IDE rules ────────────────────────────────────────────────
     console.log(chalk.bold('  Generating IDE rules...\n'));
-    await initCommand({ projectRoot: options.projectRoot, staging: options.staging });
+    await initCommand({
+        projectRoot: options.projectRoot,
+        staging: options.staging,
+        sourceSurface: options.sourceSurface,
+        campaign: options.campaign,
+        queryCluster: options.queryCluster,
+        hostAgent: options.hostAgent,
+    });
     if (idToken) {
         const installId = await registerAgentInstall({
             idToken,
             staging: options.staging,
             projectRoot,
-            sourceSurface: 'cli_setup',
-            hostAgent: 'cutline-mcp-cli',
+            sourceSurface: options.sourceSurface || 'cli_setup',
+            hostAgent: options.hostAgent || 'cutline-mcp-cli',
+            campaign: options.campaign,
+            metadata: options.queryCluster
+                ? { query_cluster: options.queryCluster, discovery_flow: 'token_limit' }
+                : undefined,
         });
         if (installId) {
             await trackAgentEvent({
@@ -403,6 +414,29 @@ export async function setupCommand(options) {
                     flow: 'onboarding',
                 },
             });
+            await trackAgentEvent({
+                idToken,
+                installId,
+                eventName: 'agent_cutline_install_completed',
+                staging: options.staging,
+                eventProperties: {
+                    command: 'setup',
+                    route: 'testing_rgr',
+                },
+            });
+            if (options.queryCluster) {
+                await trackAgentEvent({
+                    idToken,
+                    installId,
+                    eventName: 'agent_token_layer_install_completed',
+                    staging: options.staging,
+                    eventProperties: {
+                        command: 'setup',
+                        query_cluster: options.queryCluster,
+                        route: 'cutline_token_layer_install',
+                    },
+                });
+            }
         }
     }
     // ── 5. Claude Code one-liners ────────────────────────────────────────────
@@ -424,9 +458,11 @@ export async function setupCommand(options) {
         const items = [
             { cmd: 'use cutline', desc: 'Magic phrase (also works with "use cutline to...", "using cutline...", "with cutline...") — Cutline infers intent and routes to the right flow' },
             { cmd: 'Run a deep dive on my product idea', desc: 'Pre-mortem analysis — risks, assumptions, experiments' },
+            { cmd: 'Write tests for this PR', desc: 'Testing intent shortcut — Cutline should route to graph-grounded test generation + RGR verification loop' },
             { cmd: 'Plan this feature with constraints from my product', desc: 'RGR plan — constraint-aware implementation roadmap' },
             { cmd: 'Run a security vibe check on this codebase', desc: 'Free security vibe check (`code_audit`) — security, reliability, and scalability (generic, not product-linked)' },
             { cmd: 'Run an engineering vibe check for my product', desc: 'Premium deep vibe check (`engineering_audit`) — product-linked analysis + RGR remediation plan' },
+            { cmd: 'use cutline to generate and run tests for this scope increase', desc: 'Preferred prompt for pervasive red/green loop execution' },
             { cmd: 'Check constraints for src/api/upload.ts', desc: 'Get NFR boundaries for a specific file' },
             { cmd: 'Generate .cutline.md for my product', desc: 'Write the constraint routing engine' },
             { cmd: 'What does my persona think about X?', desc: 'AI persona feedback on features' },
@@ -441,6 +477,8 @@ export async function setupCommand(options) {
         const items = [
             { cmd: 'use cutline', desc: 'Magic phrase (also works with "use cutline to...", "using cutline...", "with cutline...") — Cutline routes to the highest-value free flow for your intent' },
             { cmd: 'Run a security vibe check on this codebase', desc: 'Free security vibe check (`code_audit`) — security, reliability, and scalability scan (3/month free)' },
+            { cmd: 'Write tests for this PR', desc: 'Testing intent shortcut — prompts install/setup guidance if Cutline MCP is missing' },
+            { cmd: 'use cutline to generate tests for this scope increase', desc: 'Runs free-tier test-oriented routing and verification guidance where available' },
             { cmd: 'Explore a product idea', desc: 'Free 6-act discovery flow to identify pain points and opportunities' },
             { cmd: 'Continue my exploration session', desc: 'Resume and refine an existing free exploration conversation' },
         ];
@@ -454,6 +492,7 @@ export async function setupCommand(options) {
     }
     console.log();
     console.log(chalk.dim(`  cutline-mcp v${version} · docs: https://thecutline.ai/docs/setup`));
+    console.log(chalk.dim('  Testing bootstrap:'), chalk.cyan('npx -y @vibekiln/cutline-mcp-cli@latest setup'));
     console.log(chalk.dim('  Optional repo policy contract:'), chalk.cyan('cutline-mcp policy-init'));
     console.log();
 }

package/dist/index.js

@@ -64,6 +64,10 @@ program
     .option('--staging', 'Use staging environment')
     .option('--skip-login', 'Skip authentication (use existing credentials)')
     .option('--project-root <path>', 'Project root directory for IDE rules (default: cwd)')
+    .option('--source-surface <value>', 'Discovery source surface for install attribution')
+    .option('--campaign <value>', 'Campaign label for install attribution')
+    .option('--query-cluster <value>', 'Query intent cluster (e.g. token_limit_context_overflow)')
+    .option('--host-agent <value>', 'Host agent name for install attribution (default: cutline-mcp-cli)')
     .option('--hide-audit-dimension <name>', 'Hide one audit dimension in surfaced code audit output (repeatable)', (value, prev) => [...prev, value], [])
     .option('--hide-audit-dimensions <csv>', 'Hide multiple audit dimensions (comma-separated: engineering,security,reliability,scalability,compliance)')
     .action((opts) => setupCommand({
@@ -72,13 +76,28 @@ program
     projectRoot: opts.projectRoot,
     hideAuditDimension: opts.hideAuditDimension,
     hideAuditDimensions: opts.hideAuditDimensions,
+    sourceSurface: opts.sourceSurface,
+    campaign: opts.campaign,
+    queryCluster: opts.queryCluster,
+    hostAgent: opts.hostAgent,
 }));
 program
     .command('init')
     .description('Generate IDE rules only (setup runs this automatically)')
     .option('--project-root <path>', 'Project root directory (default: cwd)')
     .option('--staging', 'Use staging environment')
-    .action((opts) => initCommand({ projectRoot: opts.projectRoot, staging: opts.staging }));
+    .option('--source-surface <value>', 'Discovery source surface for install attribution')
+    .option('--campaign <value>', 'Campaign label for install attribution')
+    .option('--query-cluster <value>', 'Query intent cluster (e.g. token_limit_context_overflow)')
+    .option('--host-agent <value>', 'Host agent name for install attribution (default: cutline-mcp-cli)')
+    .action((opts) => initCommand({
+    projectRoot: opts.projectRoot,
+    staging: opts.staging,
+    sourceSurface: opts.sourceSurface,
+    campaign: opts.campaign,
+    queryCluster: opts.queryCluster,
+    hostAgent: opts.hostAgent,
+}));
 program
     .command('policy-init')
     .description('Generate repository cutline.json policy manifest for deterministic safety verification')

package/dist/servers/cutline-server.js

@@ -6596,6 +6596,11 @@ async function handleCodeAudit(args, deps) {
         },
         sensitiveDataCount: scanResult.sensitive_data.fields.length,
         rgrPlan,
+        rgrAutoTrigger: {
+          enabled: true,
+          onScopeIncrease: true,
+          executionMode: "local_vitest"
+        },
         securityGaps: graphAnalysis.securityGaps
       }
     };
@@ -7613,6 +7618,66 @@ function buildPolicyVerdictResponse(input) {
   };
 }
 
+// ../mcp/dist/mcp/src/shared/discovery-intent.js
+var TESTING_INTENT_REGEX = /\b(test|tests|testing|vitest|jest|coverage|unit test|integration test|e2e|spec file|assertion)\b/i;
+var TOKEN_INTENT_PATTERNS = [
+  { regex: /\b(rate limit|request limit|429|quota exceeded)\b/i, cluster: "rate_limit" },
+  {
+    regex: /\b(prompt (is )?too long|context window|context overflow|too many tokens|token limit)\b/i,
+    cluster: "context_overflow"
+  },
+  {
+    regex: /\b(token burn|burning credits|too expensive|reduce tokens|save tokens|token usage)\b/i,
+    cluster: "token_cost"
+  }
+];
+function isTestingIntentPrompt(prompt) {
+  return TESTING_INTENT_REGEX.test(prompt);
+}
+function detectTokenLimitIntentPrompt(prompt) {
+  for (const pattern of TOKEN_INTENT_PATTERNS) {
+    const match = prompt.match(pattern.regex);
+    if (match) {
+      return {
+        detected: true,
+        cluster: pattern.cluster,
+        matched_pattern: match[0]
+      };
+    }
+  }
+  return { detected: false };
+}
+function buildTestingIntentHintResponse(prompt) {
+  return {
+    detected: true,
+    intent: "testing",
+    route: "cutline_testing_rgr",
+    prompts: [
+      "use cutline to generate tests for this scope increase",
+      "use cutline to run the RGR loop for this change",
+      "use cutline to evaluate merge gates for this test run"
+    ],
+    bootstrap_if_missing: "npx -y @vibekiln/cutline-mcp-cli@latest setup",
+    source_prompt_excerpt: prompt.slice(0, 180)
+  };
+}
+function buildTokenLimitIntentHintResponse(prompt, match) {
+  return {
+    detected: true,
+    intent: "token_limit",
+    route: "cutline_token_layer_install",
+    query_cluster: match.cluster || "context_overflow",
+    matched_pattern: match.matched_pattern || null,
+    prompts: [
+      "use cutline to reduce context window pressure before tool calls",
+      "use cutline to apply token-saving policy and retry this flow",
+      "use cutline to install deterministic context guardrails for this repo"
+    ],
+    bootstrap_if_missing: "npx -y @vibekiln/cutline-mcp-cli@latest setup",
+    source_prompt_excerpt: prompt.slice(0, 180)
+  };
+}
+
 // ../mcp/dist/mcp/src/cutline-server.js
 function mcpAudit(entry) {
   console.error(JSON.stringify({
@@ -7649,8 +7714,29 @@ async function emitPolicyGateEvent(input) {
   } catch {
   }
 }
+async function emitAgentEvent(input) {
+  if (!input.authToken || !input.installId)
+    return;
+  const siteUrl = (process.env.NEXT_PUBLIC_SITE_URL || "https://thecutline.ai").replace(/\/$/, "");
+  try {
+    await fetch(`${siteUrl}/api/agent/event`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${input.authToken}`
+      },
+      body: JSON.stringify({
+        install_id: input.installId,
+        event_name: input.eventName,
+        event_properties: input.eventProperties || {}
+      })
+    });
+  } catch {
+  }
+}
 var DEFAULT_MODEL = process.env.MODEL_ID || "gemini-2.5-pro";
 var GOVERNANCE_ENFORCEMENT = (process.env.CUTLINE_GOVERNANCE_ENFORCEMENT || "advisory").toLowerCase() === "enforced";
+var TOKEN_INTENT_HINT_ENABLED = (process.env.CUTLINE_TOKEN_INTENT_HINT_ENABLED || "false").toLowerCase() === "true";
 function buildGovernanceEnvelope(input) {
   return {
     decision: input.decision,
@@ -8156,7 +8242,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           type: "object",
           properties: {
             prompt: { type: "string" },
-            wikiMarkdown: { type: "string" }
+            wikiMarkdown: { type: "string" },
+            auth_token: { type: "string", description: "Optional auth token for telemetry attribution" },
+            install_id: { type: "string", description: "Optional install ID for telemetry attribution" }
           },
           required: ["prompt"]
         }
@@ -8185,7 +8273,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         inputSchema: {
           type: "object",
           properties: {
-            prompt: { type: "string" }
+            prompt: { type: "string" },
+            auth_token: { type: "string", description: "Optional auth token for telemetry attribution" },
+            install_id: { type: "string", description: "Optional install ID for telemetry attribution" }
           },
           required: ["prompt"]
         }
@@ -8962,9 +9052,56 @@ Why AI: ${idea.whyAI}`
         };
       }
       if (name2 === "trial_generate") {
-        const { prompt } = args;
+        const trialArgs = args;
+        const { prompt } = trialArgs;
         const text = await cfGenerateTrialRun(prompt);
-        return { content: [{ type: "text", text: JSON.stringify({ text }) }] };
+        const isTestingIntent = isTestingIntentPrompt(prompt);
+        const tokenIntent = TOKEN_INTENT_HINT_ENABLED ? detectTokenLimitIntentPrompt(prompt) : { detected: false };
+        const env = process.env.CUTLINE_ENV === "staging" ? "staging" : "production";
+        const resolvedInstallId = trialArgs.install_id || getStoredInstallId({ environment: env });
+        if (isTestingIntent) {
+          await emitAgentEvent({
+            authToken: trialArgs.auth_token,
+            installId: resolvedInstallId || void 0,
+            eventName: "agent_test_intent_detected",
+            eventProperties: {
+              tool_name: "trial_generate",
+              route: "cutline_testing_rgr"
+            }
+          });
+        }
+        if (tokenIntent.detected) {
+          await emitAgentEvent({
+            authToken: trialArgs.auth_token,
+            installId: resolvedInstallId || void 0,
+            eventName: "agent_token_limit_intent_detected",
+            eventProperties: {
+              tool_name: "trial_generate",
+              route: "cutline_token_layer_install",
+              query_cluster: tokenIntent.cluster
+            }
+          });
+          await emitAgentEvent({
+            authToken: trialArgs.auth_token,
+            installId: resolvedInstallId || void 0,
+            eventName: "agent_token_layer_install_prompted",
+            eventProperties: {
+              tool_name: "trial_generate",
+              route: "cutline_token_layer_install",
+              query_cluster: tokenIntent.cluster
+            }
+          });
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              text,
+              ...isTestingIntent ? { cutline_testing_route: buildTestingIntentHintResponse(prompt) } : {},
+              ...tokenIntent.detected ? { cutline_token_route: buildTokenLimitIntentHintResponse(prompt, tokenIntent) } : {}
+            })
+          }]
+        };
       }
       if (name2 === "get_assurance_manifest") {
         const { url } = args;
@@ -9358,9 +9495,56 @@ Competitive threats: ${competitors}` : ""
           return { content: [{ type: "text", text: JSON.stringify(result) }] };
         }
         case "agent_chat": {
-          const { prompt, wikiMarkdown } = args;
+          const chatArgs = args;
+          const { prompt, wikiMarkdown } = chatArgs;
           const text = await cfGenerateChatSuggestion(prompt, wikiMarkdown);
-          return { content: [{ type: "text", text: JSON.stringify({ text }) }] };
+          const isTestingIntent = isTestingIntentPrompt(prompt);
+          const tokenIntent = TOKEN_INTENT_HINT_ENABLED ? detectTokenLimitIntentPrompt(prompt) : { detected: false };
+          const env = process.env.CUTLINE_ENV === "staging" ? "staging" : "production";
+          const resolvedInstallId = chatArgs.install_id || getStoredInstallId({ environment: env });
+          if (isTestingIntent) {
+            await emitAgentEvent({
+              authToken: chatArgs.auth_token,
+              installId: resolvedInstallId || void 0,
+              eventName: "agent_test_intent_detected",
+              eventProperties: {
+                tool_name: "agent_chat",
+                route: "cutline_testing_rgr"
+              }
+            });
+          }
+          if (tokenIntent.detected) {
+            await emitAgentEvent({
+              authToken: chatArgs.auth_token,
+              installId: resolvedInstallId || void 0,
+              eventName: "agent_token_limit_intent_detected",
+              eventProperties: {
+                tool_name: "agent_chat",
+                route: "cutline_token_layer_install",
+                query_cluster: tokenIntent.cluster
+              }
+            });
+            await emitAgentEvent({
+              authToken: chatArgs.auth_token,
+              installId: resolvedInstallId || void 0,
+              eventName: "agent_token_layer_install_prompted",
+              eventProperties: {
+                tool_name: "agent_chat",
+                route: "cutline_token_layer_install",
+                query_cluster: tokenIntent.cluster
+              }
+            });
+          }
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                text,
+                ...isTestingIntent ? { cutline_testing_route: buildTestingIntentHintResponse(prompt) } : {},
+                ...tokenIntent.detected ? { cutline_token_route: buildTokenLimitIntentHintResponse(prompt, tokenIntent) } : {}
+              })
+            }]
+          };
         }
         // Integrations
         case "integrations_create_issues": {
@@ -10929,6 +11113,11 @@ ${JSON.stringify(metrics, null, 2)}` }
                 ...plan,
                 entity: rgrMatched[0].name,
                 complexity,
+                auto_execution: {
+                  scope_increase_triggers_rgr: true,
+                  mode: "pervasive",
+                  expected_runner: "local_vitest"
+                },
                 governance
               }, null, 2)
             }]
@@ -11455,7 +11644,7 @@ Meta: ${JSON.stringify({
                 mode: "product",
                 codeContext: payload.codeContext || null
               });
-              runInput.productId = newJobId;
+              runInput.productId = String(auditArgs.product_id || newJobId);
               await updatePremortem(newJobId, { payload: runInput });
               return { jobId: newJobId };
             }

package/dist/utils/agent-funnel.d.ts

@@ -1,10 +1,13 @@
-type AgentEventName = 'install_completed' | 'first_tool_call_success' | 'tool_call_failed' | 'heartbeat' | 'policy_gate_passed' | 'policy_gate_blocked' | 'upgrade_clicked' | 'upgrade_completed';
+type AgentEventName = 'install_completed' | 'first_tool_call_success' | 'tool_call_failed' | 'heartbeat' | 'policy_gate_passed' | 'policy_gate_blocked' | 'upgrade_clicked' | 'upgrade_completed' | 'agent_test_intent_detected' | 'agent_cutline_install_prompted' | 'agent_cutline_install_completed' | 'agent_first_rgr_test_call_success' | 'agent_token_limit_intent_detected' | 'agent_token_layer_install_prompted' | 'agent_token_layer_install_completed';
 export declare function registerAgentInstall(input: {
     idToken: string;
     staging?: boolean;
     projectRoot: string;
     sourceSurface: string;
     hostAgent?: string;
+    campaign?: string;
+    referrerUrl?: string;
+    metadata?: Record<string, unknown>;
 }): Promise<string | null>;
 export declare function trackAgentEvent(input: {
     idToken: string;

package/dist/utils/agent-funnel.js

@@ -28,6 +28,9 @@ export async function registerAgentInstall(input) {
                 source_surface: input.sourceSurface,
                 host_agent: input.hostAgent || 'cutline-mcp-cli',
                 workspace_id: workspaceId,
+                ...(input.campaign ? { campaign: input.campaign } : {}),
+                ...(input.referrerUrl ? { referrer_url: input.referrerUrl } : {}),
+                ...(input.metadata ? { metadata: input.metadata } : {}),
             }),
         });
         if (!response.ok)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kylewadegrove/cutline-mcp-cli-staging",
-    "version": "0.3.0",
+    "version": "0.5.0",
     "description": "CLI and MCP servers for Cutline — authenticate, then run constraint-aware MCP servers in Cursor or any MCP client.",
     "type": "module",
     "main": "dist/index.js",