saasfunnels 0.2.0 → 0.2.1

package/README.md

@@ -10,10 +10,10 @@ This repository contains only the MIT-licensed CLI and its bounded runtime contr
 
 ## Install
 
-After the beta is published:
+Install the stable CLI:
 
 ```bash
-npm install --global saasfunnels@beta
+npm install --global saasfunnels
 ```
 
 ## Use
@@ -24,6 +24,49 @@ saasfunnels verify --json
 saasfunnels mcp serve
 ```
 
+### Plans and pricing
+
+```bash
+saasfunnels plans discover              # propose files, no network call
+saasfunnels plans discover --apply      # write .saasfunnels/plan-sources.json
+saasfunnels plans handoff --integration-id <id> \
+  --repository-key <repo> --repository-revision <sha> --send
+```
+
+`plans discover` reads the working tree and proposes files that define plans and
+prices. Files that reference a Stripe price are reported as evidence; files that
+only look commercial by name and content are reported separately as guesses.
+Nothing leaves the machine until `.saasfunnels/plan-sources.json` lists the files
+and `plans handoff --send` is run, because plan mapping receives file contents
+rather than the `file:line` references a feature manifest sends. Commit that file
+so the approved set is reviewable.
+
+### GitHub Action
+
+```yaml
+- uses: LeadEngine-ai/saasfunnels-cli/action@v0.2.1
+  with:
+    api-key: ${{ secrets.SAASFUNNELS_API_KEY }}
+    cli-version: 0.2.1          # pin it; a floating version rebaselines drift
+    discovery-roots: app,lib
+```
+
+On a pull request the Action scans as a `candidate`: the result is compared
+against the branch's baseline and discarded. Only the default branch advances
+the lineage. Changing `discovery-roots` starts a new lineage, so drift is
+measured against a comparable scan rather than a wider or narrower one.
+
+Plan and pricing upload is opt-in:
+
+```yaml
+    plan-sources: "true"
+    integration-id: <stripe integration id>
+```
+
+It runs only on the default branch, requires a committed
+`.saasfunnels/plan-sources.json`, and fails with an explanation rather than
+uploading anything if that file is missing.
+
 Local validation does not require credentials. Live reads use `SAASFUNNELS_API_KEY`; Direct API smoke events use `SAASFUNNELS_INGEST_API_KEY`. Set `SAASFUNNELS_API_BASE_URL` to target a controlled preview or the current SaaSFunnels host.
 
 Hosted interactive MCP uses Clerk OAuth at the application `/mcp` URL and does not require this CLI or a copied API key.

package/dist/library.js

@@ -24260,7 +24260,7 @@ function validateFeatureCatalogManifest(value) {
 
 // src/identity.ts
 var SAASFUNNELS_CLI_NAME = "saasfunnels";
-var SAASFUNNELS_CLI_VERSION = "0.1.0-beta.1";
+var SAASFUNNELS_CLI_VERSION = "0.2.1";
 var SAASFUNNELS_PRODUCT_NAME = "SaaSFunnels";
 var SAASFUNNELS_DEFAULT_API_BASE_URL = "https://app.saasfunnels.ai";
 var SAASFUNNELS_ENV = Object.freeze({

package/dist/saasfunnels.js

@@ -4001,10 +4001,10 @@ var require_resolve_block_map = __commonJS({
       let offset = bm.offset;
       let commentEnd = null;
       for (const collItem of bm.items) {
-        const { start, key: key2, sep, value } = collItem;
+        const { start, key: key2, sep: sep3, value } = collItem;
         const keyProps = resolveProps.resolveProps(start, {
           indicator: "explicit-key-ind",
-          next: key2 ?? sep?.[0],
+          next: key2 ?? sep3?.[0],
           offset,
           onError,
           parentIndent: bm.indent,
@@ -4018,7 +4018,7 @@ var require_resolve_block_map = __commonJS({
             else if ("indent" in key2 && key2.indent !== bm.indent)
               onError(offset, "BAD_INDENT", startColMsg);
           }
-          if (!keyProps.anchor && !keyProps.tag && !sep) {
+          if (!keyProps.anchor && !keyProps.tag && !sep3) {
             commentEnd = keyProps.end;
             if (keyProps.comment) {
               if (map2.comment)
@@ -4042,7 +4042,7 @@ var require_resolve_block_map = __commonJS({
         ctx.atKey = false;
         if (utilMapIncludes.mapIncludes(ctx, map2.items, keyNode))
           onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
-        const valueProps = resolveProps.resolveProps(sep ?? [], {
+        const valueProps = resolveProps.resolveProps(sep3 ?? [], {
           indicator: "map-value-ind",
           next: value,
           offset: keyNode.range[2],
@@ -4058,7 +4058,7 @@ var require_resolve_block_map = __commonJS({
             if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
               onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep3, null, valueProps, onError);
           if (ctx.schema.compat)
             utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
           offset = valueNode.range[2];
@@ -4149,7 +4149,7 @@ var require_resolve_end = __commonJS({
       let comment = "";
       if (end) {
         let hasSpace = false;
-        let sep = "";
+        let sep3 = "";
         for (const token of end) {
           const { source, type } = token;
           switch (type) {
@@ -4163,13 +4163,13 @@ var require_resolve_end = __commonJS({
               if (!comment)
                 comment = cb;
               else
-                comment += sep + cb;
-              sep = "";
+                comment += sep3 + cb;
+              sep3 = "";
               break;
             }
             case "newline":
               if (comment)
-                sep += source;
+                sep3 += source;
               hasSpace = true;
               break;
             default:
@@ -4212,18 +4212,18 @@ var require_resolve_flow_collection = __commonJS({
       let offset = fc.offset + fc.start.source.length;
       for (let i = 0; i < fc.items.length; ++i) {
         const collItem = fc.items[i];
-        const { start, key: key2, sep, value } = collItem;
+        const { start, key: key2, sep: sep3, value } = collItem;
         const props = resolveProps.resolveProps(start, {
           flow: fcName,
           indicator: "explicit-key-ind",
-          next: key2 ?? sep?.[0],
+          next: key2 ?? sep3?.[0],
           offset,
           onError,
           parentIndent: fc.indent,
           startOnNewline: false
         });
         if (!props.found) {
-          if (!props.anchor && !props.tag && !sep && !value) {
+          if (!props.anchor && !props.tag && !sep3 && !value) {
             if (i === 0 && props.comma)
               onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
             else if (i < fc.items.length - 1)
@@ -4277,8 +4277,8 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap && !sep && !props.found) {
-          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep, null, props, onError);
+        if (!isMap && !sep3 && !props.found) {
+          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep3, null, props, onError);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
           if (isBlock(value))
@@ -4290,7 +4290,7 @@ var require_resolve_flow_collection = __commonJS({
           if (isBlock(key2))
             onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
           ctx.atKey = false;
-          const valueProps = resolveProps.resolveProps(sep ?? [], {
+          const valueProps = resolveProps.resolveProps(sep3 ?? [], {
             flow: fcName,
             indicator: "map-value-ind",
             next: value,
@@ -4301,8 +4301,8 @@ var require_resolve_flow_collection = __commonJS({
           });
           if (valueProps.found) {
             if (!isMap && !props.found && ctx.options.strict) {
-              if (sep)
-                for (const st of sep) {
+              if (sep3)
+                for (const st of sep3) {
                   if (st === valueProps.found)
                     break;
                   if (st.type === "newline") {
@@ -4319,7 +4319,7 @@ var require_resolve_flow_collection = __commonJS({
             else
               onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep, null, valueProps, onError) : null;
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep3, null, valueProps, onError) : null;
           if (valueNode) {
             if (isBlock(value))
               onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
@@ -4499,7 +4499,7 @@ var require_resolve_block_scalar = __commonJS({
           chompStart = i + 1;
       }
       let value = "";
-      let sep = "";
+      let sep3 = "";
       let prevMoreIndented = false;
       for (let i = 0; i < contentStart; ++i)
         value += lines[i][0].slice(trimIndent) + "\n";
@@ -4516,24 +4516,24 @@ var require_resolve_block_scalar = __commonJS({
           indent = "";
         }
         if (type === Scalar.Scalar.BLOCK_LITERAL) {
-          value += sep + indent.slice(trimIndent) + content;
-          sep = "\n";
+          value += sep3 + indent.slice(trimIndent) + content;
+          sep3 = "\n";
         } else if (indent.length > trimIndent || content[0] === "	") {
-          if (sep === " ")
-            sep = "\n";
-          else if (!prevMoreIndented && sep === "\n")
-            sep = "\n\n";
-          value += sep + indent.slice(trimIndent) + content;
-          sep = "\n";
+          if (sep3 === " ")
+            sep3 = "\n";
+          else if (!prevMoreIndented && sep3 === "\n")
+            sep3 = "\n\n";
+          value += sep3 + indent.slice(trimIndent) + content;
+          sep3 = "\n";
           prevMoreIndented = true;
         } else if (content === "") {
-          if (sep === "\n")
+          if (sep3 === "\n")
             value += "\n";
           else
-            sep = "\n";
+            sep3 = "\n";
         } else {
-          value += sep + content;
-          sep = " ";
+          value += sep3 + content;
+          sep3 = " ";
           prevMoreIndented = false;
         }
       }
@@ -4715,25 +4715,25 @@ var require_resolve_flow_scalar = __commonJS({
       if (!match)
         return source;
       let res = match[1];
-      let sep = " ";
+      let sep3 = " ";
       let pos = first.lastIndex;
       line.lastIndex = pos;
       while (match = line.exec(source)) {
         if (match[1] === "") {
-          if (sep === "\n")
-            res += sep;
+          if (sep3 === "\n")
+            res += sep3;
           else
-            sep = "\n";
+            sep3 = "\n";
         } else {
-          res += sep + match[1];
-          sep = " ";
+          res += sep3 + match[1];
+          sep3 = " ";
         }
         pos = line.lastIndex;
       }
       const last = /[ \t]*(.*)/sy;
       last.lastIndex = pos;
       match = last.exec(source);
-      return res + sep + (match?.[1] ?? "");
+      return res + sep3 + (match?.[1] ?? "");
     }
     function doubleQuotedValue(source, onError) {
       let res = "";
@@ -5543,14 +5543,14 @@ var require_cst_stringify = __commonJS({
         }
       }
     }
-    function stringifyItem({ start, key: key2, sep, value }) {
+    function stringifyItem({ start, key: key2, sep: sep3, value }) {
       let res = "";
       for (const st of start)
         res += st.source;
       if (key2)
         res += stringifyToken(key2);
-      if (sep)
-        for (const st of sep)
+      if (sep3)
+        for (const st of sep3)
           res += st.source;
       if (value)
         res += stringifyToken(value);
@@ -6717,18 +6717,18 @@ var require_parser = __commonJS({
         if (this.type === "map-value-ind") {
           const prev = getPrevProps(this.peek(2));
           const start = getFirstKeyStartProps(prev);
-          let sep;
+          let sep3;
           if (scalar.end) {
-            sep = scalar.end;
-            sep.push(this.sourceToken);
+            sep3 = scalar.end;
+            sep3.push(this.sourceToken);
             delete scalar.end;
           } else
-            sep = [this.sourceToken];
+            sep3 = [this.sourceToken];
           const map2 = {
             type: "block-map",
             offset: scalar.offset,
             indent: scalar.indent,
-            items: [{ start, key: scalar, sep }]
+            items: [{ start, key: scalar, sep: sep3 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map2;
@@ -6881,15 +6881,15 @@ var require_parser = __commonJS({
                 } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                   const start2 = getFirstKeyStartProps(it.start);
                   const key2 = it.key;
-                  const sep = it.sep;
-                  sep.push(this.sourceToken);
+                  const sep3 = it.sep;
+                  sep3.push(this.sourceToken);
                   delete it.key;
                   delete it.sep;
                   this.stack.push({
                     type: "block-map",
                     offset: this.offset,
                     indent: this.indent,
-                    items: [{ start: start2, key: key2, sep }]
+                    items: [{ start: start2, key: key2, sep: sep3 }]
                   });
                 } else if (start.length > 0) {
                   it.sep = it.sep.concat(start, this.sourceToken);
@@ -7083,13 +7083,13 @@ var require_parser = __commonJS({
             const prev = getPrevProps(parent);
             const start = getFirstKeyStartProps(prev);
             fixFlowSeqItems(fc);
-            const sep = fc.end.splice(1, fc.end.length);
-            sep.push(this.sourceToken);
+            const sep3 = fc.end.splice(1, fc.end.length);
+            sep3.push(this.sourceToken);
             const map2 = {
               type: "block-map",
               offset: fc.offset,
               indent: fc.indent,
-              items: [{ start, key: fc, sep }]
+              items: [{ start, key: fc, sep: sep3 }]
             };
             this.onKeyLine = true;
             this.stack[this.stack.length - 1] = map2;
@@ -7371,8 +7371,8 @@ var require_dist = __commonJS({
 import { createInterface as createInterface2 } from "node:readline/promises";
 
 // src/cli.ts
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname3, join as join4, resolve as resolve4 } from "node:path";
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
 
 // src/runtime-contracts.js
 import { createHash } from "node:crypto";
@@ -22575,9 +22575,9 @@ function boundedTraitValue(value) {
 }
 function pickAccountTraits(records, keys = accountTraitKeys) {
   const traits = {};
-  for (const record3 of records) {
+  for (const record4 of records) {
     for (const key2 of keys) {
-      const value = boundedTraitValue(record3[key2]);
+      const value = boundedTraitValue(record4[key2]);
       if (value !== void 0) traits[key2] = value;
     }
   }
@@ -23310,8 +23310,8 @@ function collectSemanticCandidates(payload, source) {
     records.push({ path: "event.properties", record: objectValue2(wrappedEvent.properties) });
   }
   return records.flatMap(
-    ({ path, record: record3 }) => ["semantic_type", "event_type"].flatMap((field) => {
-      const value = nonEmptyString(record3[field]);
+    ({ path, record: record4 }) => ["semantic_type", "event_type"].flatMap((field) => {
+      const value = nonEmptyString(record4[field]);
       return value ? [{ path: path ? `${path}.${field}` : field, value }] : [];
     })
   );
@@ -24050,6 +24050,7 @@ var featureBindingKinds = [
 ];
 var defaultRoots = ["app", "src", "lib", "components", "pages"];
 var ignoredSegments = /* @__PURE__ */ new Set([
+  ".claude",
   ".git",
   ".next",
   ".output",
@@ -24653,7 +24654,7 @@ async function runFeatureSetup(input) {
       (edit) => changedEdits.some((changed) => changed.id === edit.id)
     );
     changeRecordPath = ".saasfunnels/feature-installation.json";
-    const record3 = {
+    const record4 = {
       appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
       environment: input.environment,
       files: changedEdits.map((edit) => ({
@@ -24670,7 +24671,7 @@ async function runFeatureSetup(input) {
         path: change.path
       })),
       {
-        contents: `${JSON.stringify(record3, null, 2)}
+        contents: `${JSON.stringify(record4, null, 2)}
 `,
         path: changeRecordPath
       }
@@ -24801,7 +24802,7 @@ Applied reviewed edits. Change record: ${result3.changeRecordPath}` : result3.id
 
 // src/identity.ts
 var SAASFUNNELS_CLI_NAME = "saasfunnels";
-var SAASFUNNELS_CLI_VERSION = "0.1.0-beta.1";
+var SAASFUNNELS_CLI_VERSION = "0.2.1";
 var SAASFUNNELS_PRODUCT_NAME = "SaaSFunnels";
 var SAASFUNNELS_DEFAULT_API_BASE_URL = "https://app.saasfunnels.ai";
 var SAASFUNNELS_ENV = Object.freeze({
@@ -24899,6 +24900,382 @@ function formatFeatureDriftCheckSummary(input) {
   };
 }
 
+// src/plan-branches.ts
+import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { extname as extname2, join as join2, relative as relative2, resolve as resolve2, sep } from "node:path";
+var maxPlanBranchFileCharacters = 2e6;
+var codeExtensions = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+var nonDefinitionPattern = /(^|\/)(__tests__|__mocks__|tests?|specs?|fixtures?|testing|mocks?|mock-data|stories|__stories__)(\/)|\.(test|spec|d|stories)\.[cm]?[jt]sx?$/i;
+var comparisonPattern = /\b([A-Za-z_$][\w$]*(?:\.[\w$]+)*)\s*(===|==|!==|!=)\s*(?:["'`]([A-Za-z][A-Za-z0-9_ -]{0,39})["'`]|([A-Za-z_$][\w$]*(?:\.[\w$]+){0,2}))/g;
+var planIdentifierPattern = /(plan|tier|level|subscription|package)/i;
+var enumOpenPattern = /\b(?:enum|const)\s+([A-Za-z_$][\w$]*)\s*(?:=\s*)?\{/;
+var memberPattern = /^\s*([A-Za-z_$][\w$]*)\s*[:=]\s*["'`]([A-Za-z][A-Za-z0-9_ -]{0,39})["'`]/;
+var blockClosePattern = /^\s*\}/;
+var simpleConstPattern = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::\s*[\w<>[\]|\s]+)?=\s*["'`]([A-Za-z][A-Za-z0-9_ -]{0,39})["'`]/;
+var denialPattern = /\b(?:throw|redirect|notFound|forbidden)\b|\breturn\s+(?:null|false|undefined)\b|upgrade|paywall|locked|disabled|403/i;
+var restrictionNamePattern = /\b(?:needs?|requires?|must)[A-Z_]|\b(?:is|has)?(?:Locked|Blocked|Restricted|Gated|Disabled)|upgrade|paywall/i;
+var numericBranchPattern = /\?\s*[\d_]+\s*:\s*[\d_]+|:\s*[\d_]+\s*[,;)]/;
+var renderPattern = /<[A-Z][\w.]*|className=|return\s*\(/;
+var marketingPattern = /\b(?:upgrade|get started|contact sales|choose|current plan|most popular|per month|per year|\/mo\b|\/yr\b)|\$\{?\d/i;
+var escapePattern = /\breturn\s+(?:null|false|undefined)\b|\bthrow\b|\bredirect\b|\bnotFound\b/;
+function collectConstants(lines, into) {
+  let container = null;
+  for (const line of lines) {
+    if (container && blockClosePattern.test(line)) {
+      container = null;
+      continue;
+    }
+    if (!container) {
+      const open = line.match(enumOpenPattern);
+      if (open?.[1]) {
+        container = open[1];
+        continue;
+      }
+      const simple = line.match(simpleConstPattern);
+      if (simple?.[1] && simple[2]) record3(into, simple[1], simple[2]);
+      continue;
+    }
+    const member = line.match(memberPattern);
+    if (member?.[1] && member[2]) {
+      record3(into, `${container}.${member[1]}`, member[2]);
+      record3(into, member[1], member[2]);
+    }
+  }
+}
+function record3(into, name, value) {
+  const normalized = value.toLowerCase();
+  if (!into.has(name)) {
+    into.set(name, normalized);
+    return;
+  }
+  if (into.get(name) !== normalized) into.set(name, null);
+}
+function resolveConstant(index, reference) {
+  const direct = index.get(reference);
+  if (direct !== void 0) return direct;
+  const segments = reference.split(".");
+  if (segments.length > 1) {
+    const tail = segments.slice(-2).join(".");
+    const viaTail = index.get(tail);
+    if (viaTail !== void 0) return viaTail;
+    const viaMember = index.get(segments[segments.length - 1]);
+    if (viaMember !== void 0) return viaMember;
+  }
+  return void 0;
+}
+function normalize(path) {
+  return path.split(sep).join("/");
+}
+function allowed(relativePath, excludes) {
+  if (!relativePath || relativePath.startsWith("..")) return false;
+  const segments = relativePath.split("/");
+  if (segments.some((segment) => ignoredSegments.has(segment))) return false;
+  if (segments.some((segment) => /^\.next[-.]?/.test(segment))) return false;
+  if (sensitivePathPattern.test(relativePath)) return false;
+  if (nonDefinitionPattern.test(relativePath)) return false;
+  return !excludes.some((exclude) => relativePath.startsWith(exclude));
+}
+function nearestSymbol2(lines, lineIndex) {
+  for (let index = lineIndex; index >= Math.max(0, lineIndex - 20); index -= 1) {
+    const match = lines[index]?.match(
+      /(?:export\s+)?(?:async\s+)?(?:function|class|const|let|var)\s+([A-Za-z_$][\w$]*)/
+    );
+    if (match?.[1]) return match[1];
+  }
+  return "module";
+}
+function assignedName(line) {
+  return line.match(/(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/)?.[1] ?? null;
+}
+function bindingUsages(lines, lineIndex, name) {
+  const reference = new RegExp(`\\b${name}\\b`);
+  const usages = [];
+  lines.forEach((line, index) => {
+    if (index === lineIndex || !reference.test(line)) return;
+    usages.push(line);
+  });
+  return usages.join("\n");
+}
+function shapeAt(lines, lineIndex) {
+  const line = lines[lineIndex] ?? "";
+  const window = lines.slice(lineIndex, lineIndex + 4).join("\n");
+  if (numericBranchPattern.test(line)) return "limit";
+  if (renderPattern.test(window) && marketingPattern.test(window) && !escapePattern.test(window)) {
+    return "presentation";
+  }
+  return "boolean";
+}
+function polarityAt(lines, lineIndex, negated) {
+  const window = lines.slice(lineIndex, lineIndex + 3).join("\n");
+  const bound = assignedName(lines[lineIndex] ?? "");
+  const named = bound ? restrictionNamePattern.test(bound) : false;
+  const usages = bound ? bindingUsages(lines, lineIndex, bound) : "";
+  if (!named && !denialPattern.test(window) && !denialPattern.test(usages)) {
+    return "unclear";
+  }
+  return negated ? "unclear" : "deny";
+}
+function clusterPlanBranches(branches) {
+  const clusters = /* @__PURE__ */ new Map();
+  for (const branch of branches) {
+    const segments = branch.repositoryPath.split("/");
+    const location = segments.slice(0, -1).join("/") || ".";
+    const key2 = `${branch.shape}|${location}`;
+    const existing = clusters.get(key2);
+    if (existing) existing.push(branch);
+    else clusters.set(key2, [branch]);
+  }
+  return [...clusters.entries()].map(([key2, grouped]) => {
+    const polarities = new Set(grouped.map((branch) => branch.polarity));
+    const decided = polarities.has("deny") && polarities.has("grant") ? "unclear" : polarities.has("deny") ? "deny" : polarities.has("grant") ? "grant" : "unclear";
+    return {
+      branches: grouped,
+      location: key2.slice(key2.indexOf("|") + 1),
+      planValues: [...new Set(grouped.map((branch) => branch.planValue))].sort(),
+      polarity: decided,
+      shape: grouped[0].shape
+    };
+  }).sort(
+    (left, right) => right.branches.length - left.branches.length || left.location.localeCompare(right.location)
+  );
+}
+async function discoverPlanBranches(input) {
+  const excludes = input.excludes ?? [];
+  const planValues = new Set(
+    input.planValues.map((value) => value.trim().toLowerCase()).filter(Boolean)
+  );
+  if (!planValues.size) return [];
+  const roots = input.roots ?? [".", ...defaultRoots];
+  const seen = /* @__PURE__ */ new Set();
+  const branches = [];
+  const constants = /* @__PURE__ */ new Map();
+  const pending = [];
+  const queue = roots.map((root) => resolve2(input.cwd, root));
+  while (queue.length) {
+    const current = queue.shift();
+    if (seen.has(current)) continue;
+    seen.add(current);
+    const relativePath = normalize(relative2(input.cwd, current));
+    if (relativePath && !allowed(relativePath, excludes)) continue;
+    let entryStat;
+    try {
+      entryStat = await stat2(current);
+    } catch {
+      continue;
+    }
+    if (entryStat.isDirectory()) {
+      const entries = await readdir2(current, { withFileTypes: true });
+      for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        queue.push(join2(current, entry.name));
+      }
+      continue;
+    }
+    if (!entryStat.isFile() || !relativePath) continue;
+    if (!codeExtensions.has(extname2(current).toLowerCase())) continue;
+    if (entryStat.size > maxPlanBranchFileCharacters) continue;
+    const lines = (await readFile2(current, "utf8")).split(/\r?\n/);
+    collectConstants(lines, constants);
+    lines.forEach((line, lineIndex) => {
+      comparisonPattern.lastIndex = 0;
+      let match;
+      while (match = comparisonPattern.exec(line)) {
+        const [, identifier, operator, literal2, reference] = match;
+        if (!planIdentifierPattern.test(identifier ?? "")) continue;
+        if (!literal2 && !reference) continue;
+        pending.push({
+          line: lineIndex + 1,
+          literal: literal2 ?? null,
+          negated: operator.startsWith("!"),
+          polarity: polarityAt(lines, lineIndex, operator.startsWith("!")),
+          reference: reference ?? null,
+          repositoryPath: relativePath,
+          shape: shapeAt(lines, lineIndex),
+          symbol: nearestSymbol2(lines, lineIndex)
+        });
+      }
+    });
+  }
+  for (const item of pending) {
+    const value = item.literal ? item.literal.toLowerCase() : resolveConstant(constants, item.reference);
+    if (!value || !planValues.has(value)) continue;
+    branches.push({
+      line: item.line,
+      planValue: value,
+      polarity: item.polarity,
+      repositoryPath: item.repositoryPath,
+      shape: item.shape,
+      symbol: item.symbol
+    });
+  }
+  return branches.sort(
+    (left, right) => left.repositoryPath.localeCompare(right.repositoryPath) || left.line - right.line
+  );
+}
+
+// src/plan-sources.ts
+import { readFile as readFile3, readdir as readdir3, stat as stat3, writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
+import { dirname as dirname2, extname as extname3, join as join3, relative as relative3, resolve as resolve3, sep as sep2 } from "node:path";
+var planSourceApprovalPath = ".saasfunnels/plan-sources.json";
+var maxPlanSourceFiles = 12;
+var maxPlanSourceCharacters = 512e3;
+var planSourceStems = [
+  "billing",
+  "entitlement",
+  "entitlements",
+  "plan",
+  "plans",
+  "price",
+  "prices",
+  "pricing",
+  "subscription",
+  "subscriptions",
+  "tier",
+  "tiers"
+];
+var planSourceKindByExtension = /* @__PURE__ */ new Map([
+  [".cjs", "typescript"],
+  [".js", "typescript"],
+  [".json", "json"],
+  [".jsonc", "json"],
+  [".mjs", "typescript"],
+  [".ts", "typescript"],
+  [".tsx", "typescript"],
+  [".yaml", "yaml"],
+  [".yml", "yaml"]
+]);
+var billingIntervalPattern = /\b(month|monthly|year|yearly|annual|annually|week|weekly|day|daily|recurring|interval|billing_period)\b/i;
+var chargeAmountPattern = /\b(unit_amount|unit_amount_decimal|amount|amount_decimal|price|prices|currency|usd|eur|gbp|cents)\b/i;
+var stripePriceIdPattern = /["'`]price_(?=[A-Za-z0-9]*\d)[A-Za-z0-9]{14,}["'`]/;
+var nonDefinitionPattern2 = /(^|\/)(__tests__|__mocks__|tests?|specs?)(\/)|\.(test|spec|d)\.[cm]?[jt]sx?$/i;
+var maxNamedOnlyCandidates = 10;
+function normalize2(path) {
+  return path.split(sep2).join("/");
+}
+function allowed2(relativePath, excludes) {
+  if (!relativePath || relativePath.startsWith("..")) return false;
+  const segments = relativePath.split("/");
+  if (segments.some((segment) => ignoredSegments.has(segment))) return false;
+  if (segments.some((segment) => /^\.next[-.]?/.test(segment))) return false;
+  if (sensitivePathPattern.test(relativePath)) return false;
+  if (nonDefinitionPattern2.test(relativePath)) return false;
+  return !excludes.some((exclude) => relativePath.startsWith(exclude));
+}
+function looksLikePlanSource(relativePath) {
+  const base = relativePath.split("/").pop() ?? "";
+  const stem = base.slice(0, base.length - extname3(base).length).toLowerCase();
+  const parts = stem.split(/[^a-z0-9]+/).filter(Boolean);
+  return parts.some((part) => planSourceStems.includes(part));
+}
+async function discoverPlanSourceCandidates(input) {
+  const excludes = input.excludes ?? [];
+  const roots = input.roots ?? [".", "config", ...defaultRoots];
+  const seen = /* @__PURE__ */ new Set();
+  const candidates = [];
+  const queue = roots.map((root) => resolve3(input.cwd, root));
+  while (queue.length && candidates.length < 200) {
+    const current = queue.shift();
+    if (seen.has(current)) continue;
+    seen.add(current);
+    const relativePath = normalize2(relative3(input.cwd, current));
+    if (relativePath && !allowed2(relativePath, excludes)) continue;
+    let entryStat;
+    try {
+      entryStat = await stat3(current);
+    } catch {
+      continue;
+    }
+    if (entryStat.isDirectory()) {
+      const entries = await readdir3(current, { withFileTypes: true });
+      for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        queue.push(join3(current, entry.name));
+      }
+      continue;
+    }
+    if (!entryStat.isFile()) continue;
+    const kind = planSourceKindByExtension.get(extname3(current).toLowerCase());
+    if (!kind || !relativePath) continue;
+    if (entryStat.size > maxPlanSourceCharacters) continue;
+    const contents = await readFile3(current, "utf8");
+    const hasStripePriceId = stripePriceIdPattern.test(contents);
+    const named = looksLikePlanSource(relativePath);
+    const looksPriced = billingIntervalPattern.test(contents) && chargeAmountPattern.test(contents);
+    if (!hasStripePriceId && !(named && looksPriced)) continue;
+    candidates.push({
+      characters: contents.length,
+      confidenceBasisPoints: hasStripePriceId ? 9e3 : 4e3,
+      hasStripePriceId,
+      kind,
+      path: relativePath,
+      rationale: hasStripePriceId ? named ? "Filename suggests commercial configuration and the file references a Stripe price." : "The file references a Stripe price." : "Filename suggests commercial configuration and the file states amounts and billing intervals."
+    });
+  }
+  const sorted = candidates.sort(
+    (left, right) => right.confidenceBasisPoints - left.confidenceBasisPoints || left.path.localeCompare(right.path)
+  );
+  const confirmed = sorted.filter((candidate) => candidate.hasStripePriceId);
+  const namedOnly = sorted.filter((candidate) => !candidate.hasStripePriceId);
+  return [...confirmed, ...namedOnly.slice(0, maxNamedOnlyCandidates)];
+}
+async function readApprovedPlanSources(cwd2) {
+  try {
+    const raw = await readFile3(resolve3(cwd2, planSourceApprovalPath), "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.files) ? parsed.files.filter((value) => typeof value === "string") : [];
+  } catch {
+    return [];
+  }
+}
+async function writeApprovedPlanSources(cwd2, files) {
+  const target = resolve3(cwd2, planSourceApprovalPath);
+  await mkdir2(dirname2(target), { recursive: true });
+  await writeFile2(
+    target,
+    `${JSON.stringify(
+      {
+        files: [...files].sort(),
+        note: "Only these files are uploaded for plan mapping. Review before committing.",
+        schemaVersion: 1
+      },
+      null,
+      2
+    )}
+`,
+    "utf8"
+  );
+  return target;
+}
+async function buildPlanMappingHandoff(input) {
+  if (input.files.length > maxPlanSourceFiles) {
+    throw new Error(
+      `Plan mapping accepts at most ${maxPlanSourceFiles} files; ${input.files.length} are approved. Remove some from ${planSourceApprovalPath}.`
+    );
+  }
+  const observedAt = input.observedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const inputs = [];
+  for (const file2 of [...input.files].sort()) {
+    const relativePath = normalize2(file2);
+    if (!allowed2(relativePath, [])) {
+      throw new Error(`${relativePath} is not a readable plan source path.`);
+    }
+    const kind = planSourceKindByExtension.get(extname3(relativePath).toLowerCase());
+    if (!kind) {
+      throw new Error(`${relativePath} is not a supported plan source type.`);
+    }
+    const content = await readFile3(resolve3(input.cwd, relativePath), "utf8");
+    if (content.length > maxPlanSourceCharacters) {
+      throw new Error(
+        `${relativePath} is ${content.length} characters; the limit is ${maxPlanSourceCharacters}.`
+      );
+    }
+    inputs.push({ content, kind, label: relativePath, observedAt });
+  }
+  return { inputs };
+}
+function planMappingRequestKey(input) {
+  const slug = `${input.repositoryKey}:${input.repositoryRevision}`.toLowerCase().replace(/[^a-z0-9_.:-]+/g, "-").replace(/^-+|-+$/g, "");
+  return `plans-${slug}`.slice(0, 160);
+}
+
 // src/mcp.ts
 import { createInterface } from "node:readline";
 
@@ -26194,7 +26571,15 @@ async function serveSaaSFunnelsMcp(options = {}) {
 var cliSchemaVersion = "2026-07-02.1";
 var targetNames = /* @__PURE__ */ new Set(["codex", "claude-code", "cursor", "markdown"]);
 var sourceNames2 = /* @__PURE__ */ new Set(["direct", "posthog", "segment"]);
-var tokenPattern2 = /\b((?:pv|sk|pk|rk|whsec|xox[baprs]|gh[pousr])_[A-Za-z0-9_=-]{8,}|[A-Za-z0-9_-]{32,})\b/g;
+var tokenPattern2 = /\b((?:pv|sk|pk|rk|whsec|xox[baprs]|gh[pousr])_[A-Za-z0-9_=-]{8,}|(?=[A-Za-z0-9_-]*\d)[A-Za-z0-9_-]{32,})\b/g;
+var pathValuedKeys = /* @__PURE__ */ new Set([
+  "approvalPath",
+  "file",
+  "files",
+  "location",
+  "path",
+  "repositoryPath"
+]);
 function parseArgs2(argv2) {
   const args = [];
   const flags = {};
@@ -26240,9 +26625,30 @@ function result(exitCode, stdout = "", stderr = "") {
     stdout: redactOutput(stdout)
   };
 }
+function redactStructured(value, key2) {
+  if (typeof value === "string") {
+    return key2 && pathValuedKeys.has(key2) ? value : redactOutput(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactStructured(item, key2));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([name, item]) => [
+        name,
+        redactStructured(item, name)
+      ])
+    );
+  }
+  return value;
+}
 function jsonResult(exitCode, data) {
-  return result(exitCode, `${JSON.stringify(data, null, 2)}
-`);
+  return {
+    exitCode,
+    stderr: "",
+    stdout: `${JSON.stringify(redactStructured(data), null, 2)}
+`
+  };
 }
 function usage() {
   return `${SAASFUNNELS_PRODUCT_NAME} CLI
@@ -26256,6 +26662,10 @@ Usage:
   ${SAASFUNNELS_CLI_NAME} features setup [--root <paths>] [--exclude <paths>] [--accept <ids|all>] [--reject <ids>] [--map <id=key>] [--manifest-only] [--apply] [--json]
   ${SAASFUNNELS_CLI_NAME} features check --feature <key> --account-id <uuid> [--environment test] [--json]
   ${SAASFUNNELS_CLI_NAME} features handoff [--file <path>] --repository-revision <revision> --repository-key <key> [--discovery-roots <paths>] [--scan-role series|candidate] [--producer cli|github_action|github_app] [--send] [--json]
+  ${SAASFUNNELS_CLI_NAME} plans discover [--root <paths>] [--exclude <paths>] [--apply] [--json]
+  ${SAASFUNNELS_CLI_NAME} plans branches --plans <names> [--root <paths>] [--json]
+  ${SAASFUNNELS_CLI_NAME} plans branches --plans <names> --repository-key <repo> --repository-revision <sha> --send
+  ${SAASFUNNELS_CLI_NAME} plans handoff --repository-key <key> --repository-revision <rev> --integration-id <uuid> [--send] [--json]
   ${SAASFUNNELS_CLI_NAME} catalog discover [feature setup options]
   ${SAASFUNNELS_CLI_NAME} catalog validate [file] [--json]
   ${SAASFUNNELS_CLI_NAME} catalog diff [feature setup options]
@@ -26278,10 +26688,10 @@ function flagList(flags, name) {
 function filesystem(options) {
   return options.fs ?? {
     mkdir: async (path, mkdirOptions) => {
-      await mkdir2(path, mkdirOptions);
+      await mkdir3(path, mkdirOptions);
     },
-    readFile: readFile2,
-    writeFile: writeFile2
+    readFile: readFile4,
+    writeFile: writeFile3
   };
 }
 function cwd(options) {
@@ -26311,19 +26721,19 @@ function sourceFlag(flags) {
 }
 async function readJsonFile(filePath, options) {
   const raw = await filesystem(options).readFile(
-    resolve2(cwd(options), filePath),
+    resolve4(cwd(options), filePath),
     "utf8"
   );
   return JSON.parse(raw);
 }
 async function commandInit(flags, options) {
   const fs = filesystem(options);
-  const configPath = join2(cwd(options), ".saasfunnels", "config.json");
+  const configPath = join4(cwd(options), ".saasfunnels", "config.json");
   const config2 = {
     api_base_url: apiBaseUrl2(options, flags),
     schema_version: cliSchemaVersion
   };
-  await fs.mkdir(dirname2(configPath), { recursive: true });
+  await fs.mkdir(dirname3(configPath), { recursive: true });
   await fs.writeFile(
     configPath,
     `${JSON.stringify(config2, null, 2)}
@@ -26358,9 +26768,9 @@ async function commandAgentInstall(args, flags, options) {
   const artifacts = getDeveloperToolAgentHandoffArtifacts({ endpoint });
   const artifact = artifacts[target];
   const targetPath = flagString(flags, "path") ?? saasFunnelsPublicText(artifact.target_path);
-  const absoluteTarget = join2(cwd(options), targetPath);
+  const absoluteTarget = join4(cwd(options), targetPath);
   const fs = filesystem(options);
-  await fs.mkdir(dirname2(absoluteTarget), { recursive: true });
+  await fs.mkdir(dirname3(absoluteTarget), { recursive: true });
   await fs.writeFile(
     absoluteTarget,
     saasFunnelsPublicText(artifact.file_contents),
@@ -26500,7 +26910,7 @@ async function commandFeatures(args, flags, options) {
     }
     const discoveryRoots = (flagString(flags, "discovery-roots") ?? "").split(",").map((root) => root.trim()).filter(Boolean);
     const source = await filesystem(options).readFile(
-      resolve2(cwd(options), path),
+      resolve4(cwd(options), path),
       "utf8"
     );
     const validation = parseFeatureManifestSource(source);
@@ -26516,7 +26926,7 @@ ${validation.errors.map((error51) => `- ${error51}`).join("\n")}
     let sdkVersions = [];
     try {
       const packageSource = await filesystem(options).readFile(
-        resolve2(cwd(options), "package.json"),
+        resolve4(cwd(options), "package.json"),
         "utf8"
       );
       sdkVersions = featureSdkVersionsFromPackageJson(
@@ -26566,8 +26976,7 @@ ${validation.errors.map((error51) => `- ${error51}`).join("\n")}
         "Feature instrumentation handoff accepted. Open the Features review link returned by SaaSFunnels.\n"
       ) : result(1, "", "Feature instrumentation handoff was rejected.\n");
     }
-    return jsonMode(flags) ? jsonResult(0, handoff) : result(0, `${JSON.stringify(handoff, null, 2)}
-`);
+    return jsonMode(flags) ? jsonResult(0, handoff) : jsonResult(0, handoff);
   }
   return result(
     2,
@@ -26588,7 +26997,7 @@ async function commandCatalog(args, flags, options) {
   if (action === "validate") {
     const path = args[1] ?? ".saasfunnels/catalog.yaml";
     const source = await filesystem(options).readFile(
-      resolve2(cwd(options), path),
+      resolve4(cwd(options), path),
       "utf8"
     );
     const validation = parseFeatureManifestSource(source);
@@ -26838,7 +27247,7 @@ async function commandVerify(flags, options) {
   if (catalogPath) {
     try {
       const source = await filesystem(options).readFile(
-        resolve2(cwd(options), catalogPath),
+        resolve4(cwd(options), catalogPath),
         "utf8"
       );
       const validation = parseFeatureManifestSource(source);
@@ -26946,6 +27355,236 @@ async function commandMcp(args, flags, options) {
   return result(2, "", `Usage: ${SAASFUNNELS_CLI_NAME} mcp serve
 `);
 }
+async function commandPlans(args, flags, options) {
+  if (args[0] === "branches") {
+    const planValues = flagList(flags, "plans");
+    if (!planValues.length)
+      return result(
+        2,
+        "",
+        "Missing --plans with the plan names from your Stripe catalog.\n"
+      );
+    const branches = await discoverPlanBranches({
+      cwd: cwd(options),
+      excludes: flagList(flags, "exclude"),
+      planValues,
+      roots: flagList(flags, "root").length ? flagList(flags, "root") : void 0
+    });
+    const clusters = clusterPlanBranches(branches);
+    if (flags.json) {
+      return jsonResult(0, { branches, clusters });
+    }
+    if (!branches.length) {
+      return result(
+        0,
+        "No plan branches found. This codebase may read entitlements rather than comparing plan names.\n",
+        ""
+      );
+    }
+    const lines = [
+      `${branches.length} plan branch(es) in ${clusters.length} group(s):`,
+      ""
+    ];
+    for (const cluster of clusters) {
+      const polarity = cluster.polarity === "deny" ? "restricts" : cluster.polarity === "grant" ? "grants" : "unclear";
+      lines.push(
+        `  ${cluster.location} \u2014 ${cluster.planValues.join(", ")} (${cluster.shape}, ${polarity}, ${cluster.branches.length} site(s))`
+      );
+    }
+    lines.push("");
+    lines.push("Each group is one place your product differs by plan. Naming what");
+    lines.push("each one gates is a review step; nothing is guessed here.");
+    if (!hasFlag(flags, "send")) {
+      lines.push("");
+      lines.push("Add --send to hand these to your workspace for review.");
+      return result(0, `${lines.join("\n")}
+`, "");
+    }
+    const repositoryKey = flagString(flags, "repository-key");
+    if (!repositoryKey)
+      return result(2, "", "Missing --repository-key for the plan branch handoff.\n");
+    const repositoryRevision = flagString(flags, "repository-revision");
+    if (!repositoryRevision)
+      return result(2, "", "Missing --repository-revision for the plan branch handoff.\n");
+    const key2 = envValue2(options, SAASFUNNELS_ENV.apiKey);
+    if (!key2)
+      return result(2, "", "Missing SAASFUNNELS_API_KEY with features:write for --send.\n");
+    const payload = {
+      clusters: clusters.map((cluster) => ({
+        branchCount: cluster.branches.length,
+        branches: cluster.branches.map((branch) => ({
+          line: branch.line,
+          planValue: branch.planValue,
+          polarity: branch.polarity,
+          repositoryPath: branch.repositoryPath,
+          shape: branch.shape,
+          symbol: branch.symbol
+        })),
+        location: cluster.location,
+        planValues: cluster.planValues,
+        polarity: cluster.polarity,
+        shape: cluster.shape
+      })),
+      environment: flagString(flags, "environment") ?? "test",
+      planValues,
+      producer: flagString(flags, "producer") ?? "cli",
+      repositoryKey,
+      repositoryRevision,
+      schemaVersion: 1
+    };
+    const response = await (options.fetch ?? fetch)(
+      `${apiBaseUrl2(options, flags)}/api/developer-tools/plans/branches`,
+      {
+        body: JSON.stringify(payload),
+        headers: {
+          authorization: `Bearer ${key2}`,
+          "content-type": "application/json"
+        },
+        method: "POST"
+      }
+    );
+    const body = await response.json();
+    if (!response.ok)
+      return result(1, "", `${body.error ?? "The plan branch handoff failed."}
+`);
+    if (jsonMode(flags)) return jsonResult(0, body.data ?? {});
+    lines.push("");
+    lines.push(`Sent ${body.data?.clusterCount ?? clusters.length} group(s) for review.`);
+    if (body.data?.retainedReviews)
+      lines.push(
+        `${body.data.retainedReviews} already reviewed and left as answered.`
+      );
+    if (body.data?.reviewUrl) lines.push(body.data.reviewUrl);
+    return result(0, `${lines.join("\n")}
+`, "");
+  }
+  if (args[0] === "discover") {
+    const candidates = await discoverPlanSourceCandidates({
+      cwd: cwd(options),
+      excludes: flagList(flags, "exclude"),
+      roots: flagList(flags, "root").length ? flagList(flags, "root") : void 0
+    });
+    if (!candidates.length) {
+      return jsonMode(flags) ? jsonResult(0, { candidates: [], ok: true }) : result(
+        0,
+        "No plan or pricing definition files found. Map plans to Features in SaaSFunnels instead.\n"
+      );
+    }
+    const approved = candidates.slice(0, maxPlanSourceFiles);
+    if (hasFlag(flags, "apply")) {
+      if (options.prompt) {
+        const confirmation = await options.prompt(
+          `Approve these files for upload to SaaSFunnels: ${approved.map((candidate) => candidate.path).join(", ")}? [y/N] `
+        );
+        if (!/^y(?:es)?\$/i.test(confirmation.trim())) {
+          return result(2, "", "Plan source approval was cancelled.\n");
+        }
+      }
+      await writeApprovedPlanSources(
+        cwd(options),
+        approved.map((candidate) => candidate.path)
+      );
+    }
+    if (jsonMode(flags))
+      return jsonResult(0, {
+        approvalPath: planSourceApprovalPath,
+        candidates,
+        ok: true,
+        written: hasFlag(flags, "apply")
+      });
+    const confirmed = candidates.filter((candidate) => candidate.hasStripePriceId);
+    const namedOnly = candidates.filter((candidate) => !candidate.hasStripePriceId);
+    const lines = [];
+    if (confirmed.length) {
+      lines.push("Defines Stripe prices:");
+      confirmed.forEach(
+        (candidate) => lines.push(`  ${candidate.path} (${candidate.kind})`)
+      );
+    }
+    if (namedOnly.length) {
+      if (confirmed.length) lines.push("");
+      lines.push(
+        confirmed.length ? "Named like pricing configuration, no Stripe price found:" : "No file defines a Stripe price. These matched by name only:"
+      );
+      namedOnly.forEach(
+        (candidate) => lines.push(`  ${candidate.path} (${candidate.kind})`)
+      );
+    }
+    return result(
+      0,
+      `${lines.join("\n")}
+
+${hasFlag(flags, "apply") ? `Approved ${approved.length} file(s) in ${planSourceApprovalPath}. Review and commit it.` : `Re-run with --apply to record these in ${planSourceApprovalPath}.`}
+`
+    );
+  }
+  if (args[0] === "handoff") {
+    const repositoryKey = flagString(flags, "repository-key");
+    if (!repositoryKey)
+      return result(2, "", "Missing --repository-key for the plan mapping handoff.\n");
+    const repositoryRevision = flagString(flags, "repository-revision");
+    if (!repositoryRevision)
+      return result(
+        2,
+        "",
+        "Missing --repository-revision for the plan mapping handoff.\n"
+      );
+    const integrationId = flagString(flags, "integration-id");
+    if (!integrationId)
+      return result(2, "", "Missing --integration-id for the plan mapping handoff.\n");
+    const files = await readApprovedPlanSources(cwd(options));
+    if (!files.length)
+      return result(
+        2,
+        "",
+        `No approved plan sources. Run "${SAASFUNNELS_CLI_NAME} plans discover --apply" and commit ${planSourceApprovalPath}.
+`
+      );
+    const { inputs } = await buildPlanMappingHandoff({ cwd: cwd(options), files });
+    const requestKey = planMappingRequestKey({ repositoryKey, repositoryRevision });
+    if (!hasFlag(flags, "send")) {
+      return jsonMode(flags) ? jsonResult(0, {
+        files: inputs.map((entry) => entry.label),
+        ok: true,
+        requestKey
+      }) : result(
+        0,
+        `Would upload for plan mapping:
+${inputs.map((entry) => `- ${entry.label}`).join("\n")}
+
+Add --send to upload.
+`
+      );
+    }
+    const key2 = envValue2(options, SAASFUNNELS_ENV.apiKey);
+    if (!key2)
+      return result(
+        2,
+        "",
+        "Missing SAASFUNNELS_API_KEY with catalog access for --send.\n"
+      );
+    const response = await (options.fetch ?? fetch)(
+      `${apiBaseUrl2(options, flags)}/api/funnels/catalog/plan-mapping/imports`,
+      {
+        body: JSON.stringify({ inputs, integrationId, requestKey }),
+        headers: {
+          authorization: `Bearer ${key2}`,
+          "content-type": "application/json"
+        },
+        method: "POST"
+      }
+    );
+    const body = await response.json();
+    return jsonMode(flags) ? jsonResult(response.ok ? 0 : 1, body) : response.ok ? result(
+      0,
+      `Staged ${inputs.length} plan source(s) for review in SaaSFunnels.
+`
+    ) : result(1, "", "The plan mapping handoff was rejected.\n");
+  }
+  return result(2, "", `Unknown plans command.
+
+${usage()}`);
+}
 async function runSaaSFunnelsCli(argv2, options = {}) {
   const parsed = parseArgs2(argv2);
   const [command, ...args] = parsed.args;
@@ -26961,6 +27600,8 @@ async function runSaaSFunnelsCli(argv2, options = {}) {
       return await commandFeatures(args, parsed.flags, options);
     if (command === "catalog")
       return await commandCatalog(args, parsed.flags, options);
+    if (command === "plans")
+      return await commandPlans(args, parsed.flags, options);
     if (command === "doctor") return await commandDoctor(parsed.flags, options);
     if (command === "readiness")
       return await commandReadiness(parsed.flags, options);

package/dist/types/feature-setup.d.ts

@@ -1,6 +1,9 @@
 import { mkdir, rename, rm, writeFile } from "node:fs/promises";
 import { z } from "zod";
 declare const featureBindingKinds: readonly ["server_enforcement", "browser_presentation", "usage_reporter", "funnel_trigger", "discovery"];
+export declare const defaultRoots: string[];
+export declare const ignoredSegments: Set<string>;
+export declare const sensitivePathPattern: RegExp;
 export declare const featureCatalogManifestSchema: z.ZodObject<{
     environment: z.ZodEnum<{
         test: "test";

package/dist/types/identity.d.ts

@@ -1,5 +1,5 @@
 export declare const SAASFUNNELS_CLI_NAME = "saasfunnels";
-export declare const SAASFUNNELS_CLI_VERSION = "0.1.0-beta.1";
+export declare const SAASFUNNELS_CLI_VERSION = "0.2.1";
 export declare const SAASFUNNELS_PRODUCT_NAME = "SaaSFunnels";
 export declare const SAASFUNNELS_DEFAULT_API_BASE_URL = "https://app.saasfunnels.ai";
 export declare const SAASFUNNELS_ENV: Readonly<{

package/dist/types/mcp.d.ts

@@ -68,7 +68,7 @@ export type SaaSFunnelsMcpOptions = {
     output?: Pick<NodeJS.WritableStream, "write">;
 };
 declare const mcpProtocolVersion = "2025-06-18";
-declare const mcpServerVersion = "0.1.0-beta.1";
+declare const mcpServerVersion = "0.2.1";
 export declare function saasFunnelsMcpResources(): McpResourceDefinition[];
 export declare function readSaaSFunnelsMcpResource(uri: string, options?: SaaSFunnelsMcpOptions): string;
 export declare function saasFunnelsMcpToolDefinitions({ allowFunnelTests, allowFunnelWrites, allowTestWrites, includeHostedAccountTools, }?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saasfunnels",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "private": false,
   "description": "SaaSFunnels CLI and local stdio MCP server",
   "author": "SaaSFunnels",
@@ -57,7 +57,8 @@
     "verify:metadata": "node scripts/verify-package-metadata.mjs",
     "verify:pack": "node scripts/verify-pack.mjs",
     "verify:installed": "node scripts/smoke-installed-package.mjs",
-    "release:verify": "npm run typecheck && npm test && npm run security:secrets && npm run security:audit && npm run verify:metadata && npm run verify:pack && npm run verify:installed"
+    "release:verify": "npm run typecheck && npm test && npm run security:secrets && npm run security:audit && npm run verify:metadata && npm run verify:pack && npm run verify:installed",
+    "eval": "node eval/run.mjs"
   },
   "devDependencies": {
     "@npmcli/package-json": "7.0.5",