@outlit/cli 2.0.0 → 3.0.0

package/dist/cli.js

@@ -104,7 +104,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@outlit/cli",
-    version: "2.0.0",
+    version: "3.0.0",
     description: "CLI for querying Outlit customer context and installing agent skills",
     license: "Apache-2.0",
     repository: {
@@ -147,12 +147,13 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@clack/prompts": "^1.0.1",
-      "@outlit/tools": "^1.0.0",
+      "@outlit/tools": "^2.0.0",
       citty: "^0.2.1"
     },
     devDependencies: {
-      typescript: "^5.9.3",
-      "@types/bun": "latest"
+      "@types/bun": "latest",
+      "node-pty": "^1.1.0",
+      typescript: "^5.9.3"
     }
   };
 });
@@ -772,7 +773,7 @@ var import_picocolors, import_sisteransi, at = (t) => t === 161 || t === 164 ||
 ` && (r && p && (i += st(r)), n && (i += it(n))), V += h.length, m = A, A = g.next();
   }
   return i;
-}, At, _, bt, z, rt = (t) => ("columns" in t) && typeof t.columns == "number" ? t.columns : 80, nt = (t) => ("rows" in t) && typeof t.rows == "number" ? t.rows : 20, Vt, yt, Mt, Wt;
+}, At, _, bt, z, rt = (t) => ("columns" in t) && typeof t.columns == "number" ? t.columns : 80, nt = (t) => ("rows" in t) && typeof t.rows == "number" ? t.rows : 20, Vt, kt, yt, Mt, Wt, $t;
 var init_dist2 = __esm(() => {
   import_picocolors = __toESM(require_picocolors(), 1);
   import_sisteransi = __toESM(require_src(), 1);
@@ -851,6 +852,23 @@ var init_dist2 = __esm(() => {
       }
     }
   };
+  kt = class kt extends x {
+    get cursor() {
+      return this.value ? 0 : 1;
+    }
+    get _value() {
+      return this.cursor === 0;
+    }
+    constructor(e) {
+      super(e, false), this.value = !!e.initialValue, this.on("userInput", () => {
+        this.value = this._value;
+      }), this.on("confirm", (s) => {
+        this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = s, this.state = "submit", this.close();
+      }), this.on("cursor", () => {
+        this.value = !this.value;
+      });
+    }
+  };
   yt = class yt extends x {
     options;
     cursor = 0;
@@ -951,6 +969,27 @@ var init_dist2 = __esm(() => {
       });
     }
   };
+  $t = class $t extends x {
+    get userInputWithCursor() {
+      if (this.state === "submit")
+        return this.userInput;
+      const e = this.userInput;
+      if (this.cursor >= e.length)
+        return `${this.userInput}█`;
+      const s = e.slice(0, this.cursor), [i, ...r] = e.slice(this.cursor);
+      return `${s}${import_picocolors.default.inverse(i)}${r.join("")}`;
+    }
+    get cursor() {
+      return this._cursor;
+    }
+    constructor(e) {
+      super({ ...e, initialUserInput: e.initialUserInput ?? e.initialValue }), this.on("userInput", (s) => {
+        this._setValue(s);
+      }), this.on("finalize", () => {
+        this.value || (this.value = e.defaultValue), this.value === undefined && (this.value = "");
+      });
+    }
+  };
 });
 
 // ../../node_modules/.bun/@clack+prompts@1.0.1/node_modules/@clack/prompts/dist/index.mjs
@@ -1166,6 +1205,32 @@ var import_picocolors2, import_sisteransi2, et2, ct2 = () => process.env.CI ===
     for (const w of A)
       B2.push(w);
   return h && B2.push(g), B2;
+}, Re = (t) => {
+  const r = t.active ?? "Yes", s = t.inactive ?? "No";
+  return new kt({ active: r, inactive: s, signal: t.signal, input: t.input, output: t.output, initialValue: t.initialValue ?? true, render() {
+    const i = t.withGuide ?? _.withGuide, a = `${i ? `${import_picocolors2.default.gray(d)}
+` : ""}${W2(this.state)}  ${t.message}
+`, o = this.value ? r : s;
+    switch (this.state) {
+      case "submit": {
+        const u = i ? `${import_picocolors2.default.gray(d)}  ` : "";
+        return `${a}${u}${import_picocolors2.default.dim(o)}`;
+      }
+      case "cancel": {
+        const u = i ? `${import_picocolors2.default.gray(d)}  ` : "";
+        return `${a}${u}${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(o))}${i ? `
+${import_picocolors2.default.gray(d)}` : ""}`;
+      }
+      default: {
+        const u = i ? `${import_picocolors2.default.cyan(d)}  ` : "", l = i ? import_picocolors2.default.cyan(x2) : "";
+        return `${a}${u}${this.value ? `${import_picocolors2.default.green(Q2)} ${r}` : `${import_picocolors2.default.dim(H2)} ${import_picocolors2.default.dim(r)}`}${t.vertical ? i ? `
+${import_picocolors2.default.cyan(d)}  ` : `
+` : ` ${import_picocolors2.default.dim("/")} `}${this.value ? `${import_picocolors2.default.dim(H2)} ${import_picocolors2.default.dim(s)}` : `${import_picocolors2.default.green(Q2)} ${s}`}
+${l}
+`;
+      }
+    }
+  } }).prompt();
 }, R2, Ne = (t = "", r) => {
   (r?.output ?? process.stdout).write(`${import_picocolors2.default.gray(x2)}  ${import_picocolors2.default.red(t)}
 
@@ -1305,7 +1370,35 @@ ${n}
       }
     }
   } }).prompt();
-}, Qt;
+}, Qt, Ze = (t) => new $t({ validate: t.validate, placeholder: t.placeholder, defaultValue: t.defaultValue, initialValue: t.initialValue, output: t.output, signal: t.signal, input: t.input, render() {
+  const r = t?.withGuide ?? _.withGuide, s = `${`${r ? `${import_picocolors2.default.gray(d)}
+` : ""}${W2(this.state)}  `}${t.message}
+`, i = t.placeholder ? import_picocolors2.default.inverse(t.placeholder[0]) + import_picocolors2.default.dim(t.placeholder.slice(1)) : import_picocolors2.default.inverse(import_picocolors2.default.hidden("_")), a = this.userInput ? this.userInputWithCursor : i, o = this.value ?? "";
+  switch (this.state) {
+    case "error": {
+      const u = this.error ? `  ${import_picocolors2.default.yellow(this.error)}` : "", l = r ? `${import_picocolors2.default.yellow(d)}  ` : "", n = r ? import_picocolors2.default.yellow(x2) : "";
+      return `${s.trim()}
+${l}${a}
+${n}${u}
+`;
+    }
+    case "submit": {
+      const u = o ? `  ${import_picocolors2.default.dim(o)}` : "", l = r ? import_picocolors2.default.gray(d) : "";
+      return `${s}${l}${u}`;
+    }
+    case "cancel": {
+      const u = o ? `  ${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(o))}` : "", l = r ? import_picocolors2.default.gray(d) : "";
+      return `${s}${l}${u}${o.trim() ? `
+${l}` : ""}`;
+    }
+    default: {
+      const u = r ? `${import_picocolors2.default.cyan(d)}  ` : "", l = r ? import_picocolors2.default.cyan(x2) : "";
+      return `${s}${u}${a}
+${l}
+`;
+    }
+  }
+} }).prompt();
 var init_dist3 = __esm(() => {
   init_dist2();
   init_dist2();
@@ -1511,7 +1604,7 @@ function createOutlitClient(options) {
   return {
     key,
     baseUrl,
-    async callTool(toolName, input = {}) {
+    async callTool(toolName, input = {}, callOptions) {
       if (!isPublicToolName(toolName)) {
         throw new Error(`Unknown public tool: ${toolName}`);
       }
@@ -1524,7 +1617,8 @@ function createOutlitClient(options) {
         body: JSON.stringify({
           tool: toolName,
           input
-        })
+        }),
+        ...callOptions?.signal ? { signal: callOptions.signal } : {}
       });
       if (!response.ok) {
         const text = await response.text();
@@ -1580,17 +1674,28 @@ function matchesGeneratedJsonSchema(value, schema) {
     case "array": {
       if (!Array.isArray(value))
         return false;
+      if (schema.minItems !== undefined && value.length < schema.minItems)
+        return false;
+      if (schema.maxItems !== undefined && value.length > schema.maxItems)
+        return false;
       const itemSchema = schema.items;
       return !itemSchema || value.every((item) => matchesGeneratedJsonSchema(item, itemSchema));
     }
-    case "string":
-      return typeof value === "string";
+    case "string": {
+      if (typeof value !== "string")
+        return false;
+      if (schema.minLength !== undefined && value.length < schema.minLength)
+        return false;
+      if (schema.maxLength !== undefined && value.length > schema.maxLength)
+        return false;
+      return schema.pattern === undefined || new RegExp(schema.pattern).test(value);
+    }
     case "boolean":
       return typeof value === "boolean";
     case "number":
-      return typeof value === "number" && Number.isFinite(value);
+      return matchesNumberBounds(value, schema, false);
     case "integer":
-      return typeof value === "number" && Number.isSafeInteger(value);
+      return matchesNumberBounds(value, schema, true);
     case "null":
       return value === null;
     case undefined:
@@ -1599,13 +1704,28 @@ function matchesGeneratedJsonSchema(value, schema) {
       return false;
   }
 }
-var publicToolNames, publicToolContracts, consumerToolPolicies, toolGatewayTransport, apiKeyValidationTransport, apiKeyValidationSuccessSchema, apiKeyValidationFailureSchema, toolGatewayErrorSchema, customerBillingStatuses, customerFactStatuses, customerFactTypes, unsupportedCustomerFactTypes, customerFactCategories, customerIncludeSections, customerSourceTypes, customerSourceTypeAliasMap, customerSourceTypeAliases, customerSourceTypeInputs, customerTimeframes, timelineChannels, timelineTimeframes, userJourneyStages, workspaceUserListOrderFields, publicToolNameSet, customerSourceTypeSet, iso8601UtcDateTimeRegex, DEFAULT_OUTLIT_API_URL = "https://app.outlit.ai", OutlitToolsApiError, defaultToolNames, analyticalToolNames, cliToolNames, defaultToolNameSet, sqlToolNames;
+function matchesNumberBounds(value, schema, integer) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return false;
+  if (integer && !Number.isSafeInteger(value))
+    return false;
+  if (schema.minimum !== undefined && value < schema.minimum)
+    return false;
+  if (schema.maximum !== undefined && value > schema.maximum)
+    return false;
+  return true;
+}
+var publicToolNames, publicToolContracts, consumerToolPolicies, toolGatewayTransport, apiKeyValidationTransport, apiKeyValidationSuccessSchema, apiKeyValidationFailureSchema, toolGatewayErrorSchema, customerBillingStatuses, customerFactStatuses, customerFactTypes, unsupportedCustomerFactTypes, customerFactCategories, customerIncludeSections, customerSourceTypes, customerSourceTypeAliasMap, customerSourceTypeAliases, customerSourceTypeInputs, customerTimeframes, timelineChannels, timelineTimeframes, userJourneyStages, workspaceUserListOrderFields, publicToolNameSet, customerSourceTypeSet, iso8601UtcDateTimeRegex, DEFAULT_OUTLIT_API_URL = "https://app.outlit.ai", OutlitToolsApiError, defaultToolNames, analyticalToolNames, piToolNames, cliToolNames, defaultToolNameSet, sqlToolNames;
 var init_dist4 = __esm(() => {
   publicToolNames = [
     "outlit_list_customers",
     "outlit_list_users",
     "outlit_list_workspace_users",
     "outlit_get_customer",
+    "outlit_assign_customer_owner",
+    "outlit_grant_customer_access",
+    "outlit_update_customer_access",
+    "outlit_revoke_customer_access",
     "outlit_get_timeline",
     "outlit_list_facts",
     "outlit_get_fact",
@@ -1621,16 +1741,19 @@ var init_dist4 = __esm(() => {
     "outlit_enable_destination",
     "outlit_disable_destination",
     "outlit_archive_destination",
-    "outlit_list_integrations",
     "outlit_get_integration_capabilities",
     "outlit_begin_integration_setup",
     "outlit_get_integration_setup_status",
-    "outlit_get_integration_sync_status",
+    "outlit_get_integration_status",
+    "outlit_setup_integration",
     "outlit_get_customer_activation",
     "outlit_preview_customer_activation",
     "outlit_update_customer_activation",
     "outlit_get_workspace_settings",
-    "outlit_update_workspace_settings"
+    "outlit_update_workspace_settings",
+    "outlit_list_behavior_metric_sources",
+    "outlit_list_behavior_metric_events",
+    "outlit_create_behavior_metric"
   ];
   publicToolContracts = {
     outlit_list_customers: {
@@ -2195,7 +2318,7 @@ var init_dist4 = __esm(() => {
       commandVersion: 1,
       ownerDomain: "users",
       title: "List Workspace Users",
-      description: "Browse internal workspace users such as CSMs, managers, account owners, and admins. Use this to discover who owns customers before composing dynamic reports across account books.",
+      description: "List active workspace members who resolve to local Outlit users. Use this to discover exact user IDs for customer ownership and access commands or to browse account ownership.",
       inputSchema: {
         $schema: "https://json-schema.org/draft/2020-12/schema",
         type: "object",
@@ -2216,7 +2339,7 @@ var init_dist4 = __esm(() => {
             maxLength: 500
           },
           hasOwnedCustomers: {
-            description: "When true, return only workspace users who own at least one customer",
+            description: "When true, return only members who own customers; when false, return only members who own none",
             type: "boolean"
           },
           limit: {
@@ -3133,6 +3256,269 @@ var init_dist4 = __esm(() => {
         additionalProperties: false
       }
     },
+    outlit_assign_customer_owner: {
+      toolName: "outlit_assign_customer_owner",
+      commandId: "customer.owner.assign",
+      commandVersion: 1,
+      ownerDomain: "customers",
+      title: "Assign Customer Owner",
+      description: "Assign an active workspace member as this customer’s primary owner. The former owner keeps Editor access.",
+      inputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {
+          customerId: {
+            type: "string",
+            format: "uuid",
+            pattern: "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+          },
+          targetUserId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 500
+          }
+        },
+        required: [
+          "customerId",
+          "targetUserId"
+        ]
+      },
+      outputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {
+          customerId: {
+            type: "string"
+          },
+          ownerId: {
+            type: "string"
+          },
+          previousOwnerId: {
+            anyOf: [
+              {
+                type: "string"
+              },
+              {
+                type: "null"
+              }
+            ]
+          }
+        },
+        required: [
+          "customerId",
+          "ownerId",
+          "previousOwnerId"
+        ],
+        additionalProperties: false
+      }
+    },
+    outlit_grant_customer_access: {
+      toolName: "outlit_grant_customer_access",
+      commandId: "customer.access.grant",
+      commandVersion: 1,
+      ownerDomain: "customers",
+      title: "Grant Customer Access",
+      description: "Share a customer with an active workspace member as a Viewer or Editor. The customer ID must be exact.",
+      inputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {
+          customerId: {
+            type: "string",
+            format: "uuid",
+            pattern: "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+          },
+          targetUserId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 500
+          },
+          role: {
+            type: "string",
+            enum: [
+              "VIEWER",
+              "EDITOR"
+            ]
+          }
+        },
+        required: [
+          "customerId",
+          "targetUserId",
+          "role"
+        ]
+      },
+      outputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {
+          access: {
+            type: "object",
+            properties: {
+              customerId: {
+                type: "string"
+              },
+              userId: {
+                type: "string"
+              },
+              role: {
+                type: "string",
+                enum: [
+                  "VIEWER",
+                  "EDITOR"
+                ]
+              },
+              grantedById: {
+                anyOf: [
+                  {
+                    type: "string"
+                  },
+                  {
+                    type: "null"
+                  }
+                ]
+              }
+            },
+            required: [
+              "customerId",
+              "userId",
+              "role",
+              "grantedById"
+            ],
+            additionalProperties: false
+          }
+        },
+        required: [
+          "access"
+        ],
+        additionalProperties: false
+      }
+    },
+    outlit_update_customer_access: {
+      toolName: "outlit_update_customer_access",
+      commandId: "customer.access.update",
+      commandVersion: 1,
+      ownerDomain: "customers",
+      title: "Update Customer Access",
+      description: "Change an existing customer collaborator between Viewer and Editor.",
+      inputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {
+          customerId: {
+            type: "string",
+            format: "uuid",
+            pattern: "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+          },
+          targetUserId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 500
+          },
+          role: {
+            type: "string",
+            enum: [
+              "VIEWER",
+              "EDITOR"
+            ]
+          }
+        },
+        required: [
+          "customerId",
+          "targetUserId",
+          "role"
+        ]
+      },
+      outputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {
+          access: {
+            type: "object",
+            properties: {
+              customerId: {
+                type: "string"
+              },
+              userId: {
+                type: "string"
+              },
+              role: {
+                type: "string",
+                enum: [
+                  "VIEWER",
+                  "EDITOR"
+                ]
+              },
+              grantedById: {
+                anyOf: [
+                  {
+                    type: "string"
+                  },
+                  {
+                    type: "null"
+                  }
+                ]
+              }
+            },
+            required: [
+              "customerId",
+              "userId",
+              "role",
+              "grantedById"
+            ],
+            additionalProperties: false
+          }
+        },
+        required: [
+          "access"
+        ],
+        additionalProperties: false
+      }
+    },
+    outlit_revoke_customer_access: {
+      toolName: "outlit_revoke_customer_access",
+      commandId: "customer.access.revoke",
+      commandVersion: 1,
+      ownerDomain: "customers",
+      title: "Revoke Customer Access",
+      description: "Remove a collaborator’s explicit access to a customer.",
+      inputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {
+          customerId: {
+            type: "string",
+            format: "uuid",
+            pattern: "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+          },
+          targetUserId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 500
+          }
+        },
+        required: [
+          "customerId",
+          "targetUserId"
+        ]
+      },
+      outputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {
+          customerId: {
+            type: "string"
+          },
+          userId: {
+            type: "string"
+          }
+        },
+        required: [
+          "customerId",
+          "userId"
+        ],
+        additionalProperties: false
+      }
+    },
     outlit_get_timeline: {
       toolName: "outlit_get_timeline",
       commandId: "timeline.get",
@@ -8543,118 +8929,13 @@ Returns column definitions and example queries for each view.`,
         additionalProperties: false
       }
     },
-    outlit_list_integrations: {
-      toolName: "outlit_list_integrations",
-      commandId: "integration.list",
-      commandVersion: 1,
+    outlit_get_integration_capabilities: {
+      toolName: "outlit_get_integration_capabilities",
+      commandId: "integration.capabilities.get",
+      commandVersion: 2,
       ownerDomain: "integrations",
-      title: "List Integrations",
-      description: "List available integrations and safe connection health for the current actor.",
-      inputSchema: {
-        $schema: "https://json-schema.org/draft/2020-12/schema",
-        type: "object",
-        properties: {
-          connectedOnly: {
-            default: false,
-            type: "boolean"
-          }
-        },
-        additionalProperties: false
-      },
-      outputSchema: {
-        $schema: "https://json-schema.org/draft/2020-12/schema",
-        type: "object",
-        properties: {
-          integrations: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                provider: {
-                  type: "string",
-                  minLength: 1,
-                  maxLength: 80
-                },
-                name: {
-                  type: "string",
-                  minLength: 1,
-                  maxLength: 120
-                },
-                category: {
-                  type: "string",
-                  enum: [
-                    "crm",
-                    "communication",
-                    "storage",
-                    "calls",
-                    "calendar",
-                    "analytics",
-                    "billing",
-                    "support"
-                  ]
-                },
-                status: {
-                  type: "string",
-                  enum: [
-                    "available",
-                    "connected",
-                    "setup_required"
-                  ]
-                },
-                lastDataReceivedAt: {
-                  anyOf: [
-                    {
-                      type: "string",
-                      format: "date-time",
-                      pattern: "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$"
-                    },
-                    {
-                      type: "null"
-                    }
-                  ]
-                },
-                syncStatus: {
-                  anyOf: [
-                    {
-                      type: "string",
-                      minLength: 1,
-                      maxLength: 80
-                    },
-                    {
-                      type: "null"
-                    }
-                  ]
-                },
-                hasSyncError: {
-                  type: "boolean"
-                }
-              },
-              required: [
-                "provider",
-                "name",
-                "category",
-                "status",
-                "lastDataReceivedAt",
-                "syncStatus",
-                "hasSyncError"
-              ],
-              additionalProperties: false
-            }
-          }
-        },
-        required: [
-          "integrations"
-        ],
-        additionalProperties: false
-      }
-    },
-    outlit_get_integration_capabilities: {
-      toolName: "outlit_get_integration_capabilities",
-      commandId: "integration.capabilities.get",
-      commandVersion: 1,
-      ownerDomain: "integrations",
-      title: "Get Integration Capabilities",
-      description: "Describe safe integration setup modes without exposing credential fields or provider configuration.",
+      title: "Get Integration Capabilities",
+      description: "Describe safe integration setup modes without exposing credential fields or provider configuration.",
       inputSchema: {
         $schema: "https://json-schema.org/draft/2020-12/schema",
         type: "object",
@@ -8728,6 +9009,10 @@ Returns column definitions and example queries for each view.`,
               ],
               additionalProperties: false
             }
+          },
+          preferredSetupVersion: {
+            type: "number",
+            const: 1
           }
         },
         required: [
@@ -8875,159 +9160,965 @@ Returns column definitions and example queries for each view.`,
         additionalProperties: false
       }
     },
-    outlit_get_integration_sync_status: {
-      toolName: "outlit_get_integration_sync_status",
-      commandId: "integration.sync_status.get",
-      commandVersion: 1,
+    outlit_get_integration_status: {
+      toolName: "outlit_get_integration_status",
+      commandId: "integration.status.get",
+      commandVersion: 2,
       ownerDomain: "integrations",
-      title: "Get Integration Sync Status",
-      description: "Get safe model-level sync status for a connection visible to the current actor.",
+      title: "Get Integration Status",
+      description: "Get the configuration-readiness status for one integration or the public integration catalog.",
       inputSchema: {
         $schema: "https://json-schema.org/draft/2020-12/schema",
         type: "object",
         properties: {
           provider: {
             type: "string",
-            minLength: 1,
-            maxLength: 80
+            enum: [
+              "salesforce",
+              "hubspot",
+              "attio",
+              "slack",
+              "google-calendar",
+              "google-mail",
+              "granola",
+              "gong",
+              "fireflies",
+              "pylon",
+              "stripe",
+              "mixpanel",
+              "posthog",
+              "supabase",
+              "clerk"
+            ]
           }
         },
-        required: [
-          "provider"
-        ],
         additionalProperties: false
       },
       outputSchema: {
         $schema: "https://json-schema.org/draft/2020-12/schema",
         type: "object",
         properties: {
-          provider: {
-            type: "string",
-            minLength: 1,
-            maxLength: 80
-          },
-          name: {
-            type: "string",
-            minLength: 1,
-            maxLength: 120
-          },
-          category: {
-            type: "string",
-            enum: [
-              "crm",
-              "communication",
-              "storage",
-              "calls",
-              "calendar",
-              "analytics",
-              "billing",
-              "support"
-            ]
-          },
-          status: {
-            type: "string",
-            enum: [
-              "not_connected",
-              "connected"
-            ]
-          },
-          syncs: {
+          integrations: {
             type: "array",
             items: {
               type: "object",
               properties: {
-                model: {
+                provider: {
                   type: "string",
                   minLength: 1,
-                  maxLength: 120
+                  maxLength: 80
                 },
-                status: {
+                name: {
                   type: "string",
                   minLength: 1,
-                  maxLength: 80
+                  maxLength: 120
                 },
-                lastSyncedAt: {
-                  anyOf: [
-                    {
-                      type: "string",
-                      format: "date-time",
-                      pattern: "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$"
-                    },
-                    {
-                      type: "null"
-                    }
+                category: {
+                  type: "string",
+                  enum: [
+                    "crm",
+                    "communication",
+                    "storage",
+                    "calls",
+                    "calendar",
+                    "analytics",
+                    "billing",
+                    "support"
                   ]
                 },
-                hasError: {
-                  type: "boolean"
+                status: {
+                  type: "string",
+                  enum: [
+                    "not_connected",
+                    "awaiting_auth",
+                    "setup_required",
+                    "ready",
+                    "requires_intervention"
+                  ]
                 }
               },
               required: [
-                "model",
-                "status",
-                "lastSyncedAt",
-                "hasError"
+                "provider",
+                "name",
+                "category",
+                "status"
               ],
               additionalProperties: false
             }
           }
         },
         required: [
-          "provider",
-          "name",
-          "category",
-          "status",
-          "syncs"
+          "integrations"
         ],
         additionalProperties: false
       }
     },
-    outlit_get_customer_activation: {
-      toolName: "outlit_get_customer_activation",
-      commandId: "customer_activation.get",
+    outlit_setup_integration: {
+      toolName: "outlit_setup_integration",
+      commandId: "integration.setup.run",
       commandVersion: 1,
-      ownerDomain: "customer_activation",
-      title: "Get Customer Activation",
-      description: "Get the product event currently configured to activate customers and users.",
+      ownerDomain: "integrations",
+      title: "Set Up Integration",
+      description: "Continue integration setup through validated credentials, safe configuration, or a trusted browser handoff.",
       inputSchema: {
         $schema: "https://json-schema.org/draft/2020-12/schema",
-        type: "object",
-        properties: {},
-        additionalProperties: false
-      },
-      outputSchema: {
-        $schema: "https://json-schema.org/draft/2020-12/schema",
-        type: "object",
-        properties: {
-          activation: {
+        anyOf: [
+          {
             type: "object",
             properties: {
-              eventName: {
-                anyOf: [
-                  {
+              provider: {
+                type: "string",
+                enum: [
+                  "salesforce",
+                  "hubspot",
+                  "attio"
+                ]
+              },
+              configuration: {
+                type: "object",
+                properties: {
+                  kind: {
                     type: "string",
-                    minLength: 1,
-                    maxLength: 191
+                    const: "crm_mapping"
                   },
-                  {
-                    type: "null"
+                  mappings: {
+                    minItems: 1,
+                    type: "array",
+                    items: {
+                      type: "object",
+                      properties: {
+                        pipelineId: {
+                          type: "string",
+                          minLength: 1
+                        },
+                        pipelineName: {
+                          type: "string"
+                        },
+                        mappings: {
+                          type: "array",
+                          items: {
+                            type: "object",
+                            properties: {
+                              outlitStage: {
+                                type: "string",
+                                enum: [
+                                  "Created",
+                                  "Quoting",
+                                  "Negotiation",
+                                  "Won",
+                                  "Lost"
+                                ]
+                              },
+                              crmStages: {
+                                type: "array",
+                                items: {
+                                  type: "object",
+                                  properties: {
+                                    id: {
+                                      type: "string",
+                                      minLength: 1
+                                    },
+                                    name: {
+                                      type: "string"
+                                    }
+                                  },
+                                  required: [
+                                    "id",
+                                    "name"
+                                  ],
+                                  additionalProperties: false
+                                }
+                              }
+                            },
+                            required: [
+                              "outlitStage",
+                              "crmStages"
+                            ],
+                            additionalProperties: false
+                          }
+                        }
+                      },
+                      required: [
+                        "pipelineId",
+                        "pipelineName",
+                        "mappings"
+                      ],
+                      additionalProperties: false
+                    }
+                  },
+                  confirm: {
+                    type: "boolean",
+                    const: true
                   }
-                ]
+                },
+                required: [
+                  "kind",
+                  "mappings",
+                  "confirm"
+                ],
+                additionalProperties: false
               }
             },
             required: [
-              "eventName"
+              "provider"
             ],
             additionalProperties: false
-          }
-        },
-        required: [
-          "activation"
-        ],
-        additionalProperties: false
-      }
-    },
-    outlit_preview_customer_activation: {
+          },
+          {
+            type: "object",
+            properties: {
+              provider: {
+                type: "string",
+                enum: [
+                  "slack",
+                  "google-calendar",
+                  "google-mail",
+                  "gong"
+                ]
+              }
+            },
+            required: [
+              "provider"
+            ],
+            additionalProperties: false
+          },
+          {
+            type: "object",
+            properties: {
+              provider: {
+                type: "string",
+                const: "stripe"
+              },
+              connectionMode: {
+                type: "string",
+                const: "oauth"
+              }
+            },
+            required: [
+              "provider"
+            ],
+            additionalProperties: false
+          },
+          {
+            type: "object",
+            properties: {
+              provider: {
+                type: "string",
+                const: "stripe"
+              },
+              connectionMode: {
+                type: "string",
+                const: "restricted_key"
+              },
+              credentials: {
+                type: "object",
+                properties: {
+                  apiKey: {
+                    type: "string",
+                    minLength: 1,
+                    pattern: "^rk_.*"
+                  }
+                },
+                required: [
+                  "apiKey"
+                ],
+                additionalProperties: false
+              }
+            },
+            required: [
+              "provider",
+              "connectionMode"
+            ],
+            additionalProperties: false
+          },
+          {
+            type: "object",
+            properties: {
+              provider: {
+                type: "string",
+                const: "granola"
+              },
+              credentials: {
+                type: "object",
+                properties: {
+                  apiKey: {
+                    type: "string",
+                    minLength: 1
+                  },
+                  authScope: {
+                    default: "personal",
+                    type: "string",
+                    enum: [
+                      "personal",
+                      "enterprise"
+                    ]
+                  },
+                  enterpriseKeyAcknowledged: {
+                    default: false,
+                    type: "boolean"
+                  }
+                },
+                required: [
+                  "apiKey"
+                ],
+                additionalProperties: false
+              }
+            },
+            required: [
+              "provider"
+            ],
+            additionalProperties: false
+          },
+          {
+            type: "object",
+            properties: {
+              provider: {
+                type: "string",
+                const: "fireflies"
+              },
+              credentials: {
+                type: "object",
+                properties: {
+                  apiKey: {
+                    type: "string",
+                    minLength: 1
+                  }
+                },
+                required: [
+                  "apiKey"
+                ],
+                additionalProperties: false
+              }
+            },
+            required: [
+              "provider"
+            ],
+            additionalProperties: false
+          },
+          {
+            type: "object",
+            properties: {
+              provider: {
+                type: "string",
+                const: "pylon"
+              },
+              credentials: {
+                type: "object",
+                properties: {
+                  apiToken: {
+                    type: "string",
+                    minLength: 1
+                  }
+                },
+                required: [
+                  "apiToken"
+                ],
+                additionalProperties: false
+              }
+            },
+            required: [
+              "provider"
+            ],
+            additionalProperties: false
+          },
+          {
+            type: "object",
+            properties: {
+              provider: {
+                type: "string",
+                const: "mixpanel"
+              },
+              credentials: {
+                type: "object",
+                properties: {
+                  username: {
+                    type: "string",
+                    minLength: 1
+                  },
+                  secret: {
+                    type: "string",
+                    minLength: 1
+                  },
+                  projectId: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 64
+                  },
+                  region: {
+                    type: "string",
+                    enum: [
+                      "us",
+                      "eu",
+                      "in"
+                    ]
+                  }
+                },
+                required: [
+                  "username",
+                  "secret",
+                  "projectId",
+                  "region"
+                ],
+                additionalProperties: false
+              },
+              configuration: {
+                type: "object",
+                properties: {
+                  kind: {
+                    type: "string",
+                    const: "mixpanel_mapping"
+                  },
+                  mapping: {
+                    oneOf: [
+                      {
+                        type: "object",
+                        properties: {
+                          mode: {
+                            type: "string",
+                            const: "group_key"
+                          },
+                          groupKey: {
+                            type: "string",
+                            minLength: 1
+                          }
+                        },
+                        required: [
+                          "mode",
+                          "groupKey"
+                        ],
+                        additionalProperties: false
+                      },
+                      {
+                        type: "object",
+                        properties: {
+                          mode: {
+                            type: "string",
+                            const: "event_property"
+                          },
+                          propertyName: {
+                            type: "string",
+                            minLength: 1
+                          }
+                        },
+                        required: [
+                          "mode",
+                          "propertyName"
+                        ],
+                        additionalProperties: false
+                      },
+                      {
+                        type: "object",
+                        properties: {
+                          mode: {
+                            type: "string",
+                            const: "email_domain"
+                          }
+                        },
+                        required: [
+                          "mode"
+                        ],
+                        additionalProperties: false
+                      }
+                    ]
+                  },
+                  confirm: {
+                    type: "boolean",
+                    const: true
+                  }
+                },
+                required: [
+                  "kind",
+                  "mapping",
+                  "confirm"
+                ],
+                additionalProperties: false
+              }
+            },
+            required: [
+              "provider"
+            ],
+            additionalProperties: false
+          },
+          {
+            type: "object",
+            properties: {
+              provider: {
+                type: "string",
+                const: "posthog"
+              },
+              credentials: {
+                type: "object",
+                properties: {
+                  apiKey: {
+                    type: "string",
+                    minLength: 10,
+                    pattern: "^phx_.*"
+                  },
+                  region: {
+                    type: "string",
+                    enum: [
+                      "us",
+                      "eu"
+                    ]
+                  },
+                  projectId: {
+                    type: "string",
+                    minLength: 1,
+                    pattern: "^\\d+$"
+                  }
+                },
+                required: [
+                  "apiKey",
+                  "region",
+                  "projectId"
+                ],
+                additionalProperties: false
+              }
+            },
+            required: [
+              "provider"
+            ],
+            additionalProperties: false
+          },
+          {
+            type: "object",
+            properties: {
+              provider: {
+                type: "string",
+                enum: [
+                  "clerk",
+                  "supabase"
+                ]
+              }
+            },
+            required: [
+              "provider"
+            ],
+            additionalProperties: false
+          }
+        ]
+      },
+      outputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {
+          provider: {
+            type: "string",
+            enum: [
+              "salesforce",
+              "hubspot",
+              "attio",
+              "slack",
+              "google-calendar",
+              "google-mail",
+              "granola",
+              "gong",
+              "fireflies",
+              "pylon",
+              "stripe",
+              "mixpanel",
+              "posthog",
+              "supabase",
+              "clerk"
+            ]
+          },
+          name: {
+            type: "string",
+            minLength: 1,
+            maxLength: 120
+          },
+          category: {
+            type: "string",
+            enum: [
+              "crm",
+              "communication",
+              "storage",
+              "calls",
+              "calendar",
+              "analytics",
+              "billing",
+              "support"
+            ]
+          },
+          status: {
+            type: "string",
+            enum: [
+              "not_connected",
+              "awaiting_auth",
+              "setup_required",
+              "ready",
+              "requires_intervention"
+            ]
+          },
+          next: {
+            anyOf: [
+              {
+                anyOf: [
+                  {
+                    type: "object",
+                    properties: {
+                      kind: {
+                        type: "string",
+                        const: "browser_handoff"
+                      },
+                      purpose: {
+                        type: "string",
+                        enum: [
+                          "authentication",
+                          "recovery",
+                          "external_setup"
+                        ]
+                      },
+                      url: {
+                        type: "string",
+                        format: "uri"
+                      },
+                      sessionId: {
+                        anyOf: [
+                          {
+                            type: "string",
+                            format: "uuid",
+                            pattern: "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+                          },
+                          {
+                            type: "null"
+                          }
+                        ]
+                      },
+                      expiresAt: {
+                        anyOf: [
+                          {
+                            type: "string",
+                            format: "date-time",
+                            pattern: "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$"
+                          },
+                          {
+                            type: "null"
+                          }
+                        ]
+                      }
+                    },
+                    required: [
+                      "kind",
+                      "purpose",
+                      "url",
+                      "sessionId",
+                      "expiresAt"
+                    ],
+                    additionalProperties: false
+                  },
+                  {
+                    type: "object",
+                    properties: {
+                      kind: {
+                        type: "string",
+                        const: "crm_mapping"
+                      },
+                      recommendation: {
+                        minItems: 1,
+                        type: "array",
+                        items: {
+                          type: "object",
+                          properties: {
+                            pipelineId: {
+                              type: "string",
+                              minLength: 1
+                            },
+                            pipelineName: {
+                              type: "string"
+                            },
+                            mappings: {
+                              type: "array",
+                              items: {
+                                type: "object",
+                                properties: {
+                                  outlitStage: {
+                                    type: "string",
+                                    enum: [
+                                      "Created",
+                                      "Quoting",
+                                      "Negotiation",
+                                      "Won",
+                                      "Lost"
+                                    ]
+                                  },
+                                  crmStages: {
+                                    type: "array",
+                                    items: {
+                                      type: "object",
+                                      properties: {
+                                        id: {
+                                          type: "string",
+                                          minLength: 1
+                                        },
+                                        name: {
+                                          type: "string"
+                                        }
+                                      },
+                                      required: [
+                                        "id",
+                                        "name"
+                                      ],
+                                      additionalProperties: false
+                                    }
+                                  }
+                                },
+                                required: [
+                                  "outlitStage",
+                                  "crmStages"
+                                ],
+                                additionalProperties: false
+                              }
+                            }
+                          },
+                          required: [
+                            "pipelineId",
+                            "pipelineName",
+                            "mappings"
+                          ],
+                          additionalProperties: false
+                        }
+                      }
+                    },
+                    required: [
+                      "kind",
+                      "recommendation"
+                    ],
+                    additionalProperties: false
+                  },
+                  {
+                    type: "object",
+                    properties: {
+                      kind: {
+                        type: "string",
+                        const: "mixpanel_mapping"
+                      },
+                      preview: {
+                        type: "object",
+                        properties: {
+                          sampleSize: {
+                            type: "integer",
+                            minimum: 0,
+                            maximum: 9007199254740991
+                          },
+                          sampleWindowStartAt: {
+                            type: "string",
+                            format: "date-time",
+                            pattern: "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$"
+                          },
+                          sampleWindowEndAt: {
+                            type: "string",
+                            format: "date-time",
+                            pattern: "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$"
+                          },
+                          accountKeyCoveragePct: {
+                            type: "number",
+                            minimum: 0,
+                            maximum: 100
+                          },
+                          emailOrDomainCoveragePct: {
+                            type: "number",
+                            minimum: 0,
+                            maximum: 100
+                          },
+                          unmappedPct: {
+                            type: "number",
+                            minimum: 0,
+                            maximum: 100
+                          },
+                          matchedCustomerCount: {
+                            type: "integer",
+                            minimum: 0,
+                            maximum: 9007199254740991
+                          },
+                          opaqueOnlyUnmappedCount: {
+                            type: "integer",
+                            minimum: 0,
+                            maximum: 9007199254740991
+                          },
+                          candidateAccountKeys: {
+                            type: "array",
+                            items: {
+                              type: "object",
+                              properties: {
+                                key: {
+                                  type: "string"
+                                },
+                                count: {
+                                  type: "integer",
+                                  minimum: 0,
+                                  maximum: 9007199254740991
+                                },
+                                coveragePct: {
+                                  type: "number",
+                                  minimum: 0,
+                                  maximum: 100
+                                }
+                              },
+                              required: [
+                                "key",
+                                "count",
+                                "coveragePct"
+                              ],
+                              additionalProperties: false
+                            }
+                          },
+                          unmappedReasons: {
+                            type: "array",
+                            items: {
+                              type: "object",
+                              properties: {
+                                reason: {
+                                  type: "string",
+                                  enum: [
+                                    "missing_account_key",
+                                    "missing_email_or_domain",
+                                    "no_matching_customer"
+                                  ]
+                                },
+                                count: {
+                                  type: "integer",
+                                  minimum: 0,
+                                  maximum: 9007199254740991
+                                }
+                              },
+                              required: [
+                                "reason",
+                                "count"
+                              ],
+                              additionalProperties: false
+                            }
+                          },
+                          warnings: {
+                            type: "array",
+                            items: {
+                              type: "string"
+                            }
+                          }
+                        },
+                        required: [
+                          "sampleSize",
+                          "sampleWindowStartAt",
+                          "sampleWindowEndAt",
+                          "accountKeyCoveragePct",
+                          "emailOrDomainCoveragePct",
+                          "unmappedPct",
+                          "matchedCustomerCount",
+                          "opaqueOnlyUnmappedCount",
+                          "candidateAccountKeys",
+                          "unmappedReasons",
+                          "warnings"
+                        ],
+                        additionalProperties: false
+                      }
+                    },
+                    required: [
+                      "kind",
+                      "preview"
+                    ],
+                    additionalProperties: false
+                  }
+                ]
+              },
+              {
+                type: "null"
+              }
+            ]
+          },
+          error: {
+            anyOf: [
+              {
+                type: "object",
+                properties: {
+                  code: {
+                    type: "string",
+                    enum: [
+                      "OWNER_REQUIRED",
+                      "CONNECTION_CONFLICT",
+                      "CREDENTIAL_REQUIRED",
+                      "CREDENTIAL_REJECTED",
+                      "LEGACY_CONNECTION_REQUIRED",
+                      "HANDOFF_UNAVAILABLE",
+                      "TRANSIENT_FAILURE"
+                    ]
+                  },
+                  message: {
+                    type: "string"
+                  },
+                  retryable: {
+                    type: "boolean"
+                  }
+                },
+                required: [
+                  "code",
+                  "message",
+                  "retryable"
+                ],
+                additionalProperties: false
+              },
+              {
+                type: "null"
+              }
+            ]
+          }
+        },
+        required: [
+          "provider",
+          "name",
+          "category",
+          "status",
+          "next",
+          "error"
+        ],
+        additionalProperties: false
+      }
+    },
+    outlit_get_customer_activation: {
+      toolName: "outlit_get_customer_activation",
+      commandId: "customer_activation.get",
+      commandVersion: 1,
+      ownerDomain: "customer_activation",
+      title: "Get Customer Activation",
+      description: "Get the product event currently configured to activate customers and users.",
+      inputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      },
+      outputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {
+          activation: {
+            type: "object",
+            properties: {
+              eventName: {
+                anyOf: [
+                  {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 191
+                  },
+                  {
+                    type: "null"
+                  }
+                ]
+              }
+            },
+            required: [
+              "eventName"
+            ],
+            additionalProperties: false
+          }
+        },
+        required: [
+          "activation"
+        ],
+        additionalProperties: false
+      }
+    },
+    outlit_preview_customer_activation: {
       toolName: "outlit_preview_customer_activation",
       commandId: "customer_activation.preview",
       commandVersion: 1,
@@ -9278,67 +10369,393 @@ Returns column definitions and example queries for each view.`,
           }
         },
         required: [
-          "activation",
-          "changed"
+          "activation",
+          "changed"
+        ],
+        additionalProperties: false
+      }
+    },
+    outlit_get_workspace_settings: {
+      toolName: "outlit_get_workspace_settings",
+      commandId: "settings.get",
+      commandVersion: 1,
+      ownerDomain: "settings",
+      title: "Get Workspace Settings",
+      description: "Get the workspace default timezone used by time-based product behavior.",
+      inputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      },
+      outputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {
+          settings: {
+            type: "object",
+            properties: {
+              defaultTimezone: {
+                type: "string",
+                minLength: 1
+              }
+            },
+            required: [
+              "defaultTimezone"
+            ],
+            additionalProperties: false
+          }
+        },
+        required: [
+          "settings"
+        ],
+        additionalProperties: false
+      }
+    },
+    outlit_update_workspace_settings: {
+      toolName: "outlit_update_workspace_settings",
+      commandId: "settings.update",
+      commandVersion: 1,
+      ownerDomain: "settings",
+      title: "Update Workspace Settings",
+      description: "Update the workspace default timezone using a valid IANA timezone.",
+      inputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {
+          defaultTimezone: {
+            type: "string",
+            minLength: 1
+          }
+        },
+        required: [
+          "defaultTimezone"
+        ],
+        additionalProperties: false
+      },
+      outputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {
+          settings: {
+            type: "object",
+            properties: {
+              defaultTimezone: {
+                type: "string",
+                minLength: 1
+              }
+            },
+            required: [
+              "defaultTimezone"
+            ],
+            additionalProperties: false
+          }
+        },
+        required: [
+          "settings"
+        ],
+        additionalProperties: false
+      }
+    },
+    outlit_list_behavior_metric_sources: {
+      toolName: "outlit_list_behavior_metric_sources",
+      commandId: "behavior_metric_source.list",
+      commandVersion: 1,
+      ownerDomain: "behavior_metrics",
+      title: "List Behavior Metric Sources",
+      description: "List product-event sources eligible for Behavior Metric discovery.",
+      inputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      },
+      outputSchema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {
+          sources: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                sourceKey: {
+                  type: "string",
+                  pattern: "^metric_source_v1_[a-f0-9]{32}$"
+                },
+                provider: {
+                  type: "string",
+                  enum: [
+                    "outlit_sdk",
+                    "posthog",
+                    "mixpanel"
+                  ]
+                },
+                label: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 255
+                },
+                readiness: {
+                  type: "string",
+                  enum: [
+                    "READY",
+                    "WARMING",
+                    "BLOCKED"
+                  ]
+                }
+              },
+              required: [
+                "sourceKey",
+                "provider",
+                "label",
+                "readiness"
+              ],
+              additionalProperties: false
+            }
+          }
+        },
+        required: [
+          "sources"
         ],
         additionalProperties: false
       }
     },
-    outlit_get_workspace_settings: {
-      toolName: "outlit_get_workspace_settings",
-      commandId: "settings.get",
+    outlit_list_behavior_metric_events: {
+      toolName: "outlit_list_behavior_metric_events",
+      commandId: "behavior_metric_event.list",
       commandVersion: 1,
-      ownerDomain: "settings",
-      title: "Get Workspace Settings",
-      description: "Get the workspace default timezone used by time-based product behavior.",
+      ownerDomain: "behavior_metrics",
+      title: "List Behavior Metric Events",
+      description: "List attributed event candidates for a Behavior Metric source.",
       inputSchema: {
         $schema: "https://json-schema.org/draft/2020-12/schema",
         type: "object",
-        properties: {},
+        properties: {
+          sourceKey: {
+            type: "string",
+            pattern: "^metric_source_v1_[a-f0-9]{32}$"
+          },
+          weeks: {
+            default: 12,
+            type: "integer",
+            minimum: 1,
+            maximum: 53
+          },
+          limit: {
+            default: 100,
+            type: "integer",
+            minimum: 1,
+            maximum: 100
+          }
+        },
+        required: [
+          "sourceKey"
+        ],
         additionalProperties: false
       },
       outputSchema: {
         $schema: "https://json-schema.org/draft/2020-12/schema",
         type: "object",
         properties: {
-          settings: {
-            type: "object",
-            properties: {
-              defaultTimezone: {
-                type: "string",
-                minLength: 1
-              }
-            },
-            required: [
-              "defaultTimezone"
-            ],
-            additionalProperties: false
+          events: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                eventName: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 191
+                },
+                eventCount: {
+                  type: "integer",
+                  minimum: 0,
+                  maximum: 9007199254740991
+                },
+                distinctCustomers: {
+                  type: "integer",
+                  minimum: 0,
+                  maximum: 9007199254740991
+                },
+                activeWeeks: {
+                  type: "integer",
+                  minimum: 1,
+                  maximum: 53
+                },
+                propertyKeys: {
+                  maxItems: 10,
+                  type: "array",
+                  items: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 191
+                  }
+                }
+              },
+              required: [
+                "eventName",
+                "eventCount",
+                "distinctCustomers",
+                "activeWeeks",
+                "propertyKeys"
+              ],
+              additionalProperties: false
+            }
+          },
+          truncated: {
+            type: "boolean"
           }
         },
         required: [
-          "settings"
+          "events",
+          "truncated"
         ],
         additionalProperties: false
       }
     },
-    outlit_update_workspace_settings: {
-      toolName: "outlit_update_workspace_settings",
-      commandId: "settings.update",
+    outlit_create_behavior_metric: {
+      toolName: "outlit_create_behavior_metric",
+      commandId: "behavior_metric.create",
       commandVersion: 1,
-      ownerDomain: "settings",
-      title: "Update Workspace Settings",
-      description: "Update the workspace default timezone using a valid IANA timezone.",
+      ownerDomain: "behavior_metrics",
+      title: "Create Behavior Metric",
+      description: "Create or idempotently return an event-based Behavior Metric in ENABLED and SHADOW.",
       inputSchema: {
         $schema: "https://json-schema.org/draft/2020-12/schema",
         type: "object",
         properties: {
-          defaultTimezone: {
+          sourceKey: {
             type: "string",
-            minLength: 1
+            pattern: "^metric_source_v1_[a-f0-9]{32}$"
+          },
+          eventName: {
+            type: "string",
+            minLength: 1,
+            maxLength: 191
+          },
+          behaviorKey: {
+            type: "string",
+            maxLength: 64,
+            pattern: "^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$"
+          },
+          label: {
+            type: "string",
+            minLength: 1,
+            maxLength: 255
+          },
+          propertyFilters: {
+            default: [],
+            maxItems: 5,
+            type: "array",
+            items: {
+              oneOf: [
+                {
+                  type: "object",
+                  properties: {
+                    property: {
+                      type: "string",
+                      minLength: 1,
+                      maxLength: 191
+                    },
+                    operator: {
+                      type: "string",
+                      const: "equals"
+                    },
+                    value: {
+                      oneOf: [
+                        {
+                          type: "object",
+                          properties: {
+                            type: {
+                              type: "string",
+                              const: "string"
+                            },
+                            value: {
+                              type: "string",
+                              maxLength: 191
+                            }
+                          },
+                          required: [
+                            "type",
+                            "value"
+                          ],
+                          additionalProperties: false
+                        },
+                        {
+                          type: "object",
+                          properties: {
+                            type: {
+                              type: "string",
+                              const: "number"
+                            },
+                            value: {
+                              type: "number",
+                              minimum: -9007199254740991,
+                              maximum: 9007199254740991
+                            }
+                          },
+                          required: [
+                            "type",
+                            "value"
+                          ],
+                          additionalProperties: false
+                        },
+                        {
+                          type: "object",
+                          properties: {
+                            type: {
+                              type: "string",
+                              const: "boolean"
+                            },
+                            value: {
+                              type: "boolean"
+                            }
+                          },
+                          required: [
+                            "type",
+                            "value"
+                          ],
+                          additionalProperties: false
+                        }
+                      ]
+                    }
+                  },
+                  required: [
+                    "property",
+                    "operator",
+                    "value"
+                  ],
+                  additionalProperties: false
+                },
+                {
+                  type: "object",
+                  properties: {
+                    property: {
+                      type: "string",
+                      minLength: 1,
+                      maxLength: 191
+                    },
+                    operator: {
+                      type: "string",
+                      const: "exists"
+                    }
+                  },
+                  required: [
+                    "property",
+                    "operator"
+                  ],
+                  additionalProperties: false
+                }
+              ]
+            }
           }
         },
         required: [
-          "defaultTimezone"
+          "sourceKey",
+          "eventName",
+          "behaviorKey",
+          "label"
         ],
         additionalProperties: false
       },
@@ -9346,22 +10763,237 @@ Returns column definitions and example queries for each view.`,
         $schema: "https://json-schema.org/draft/2020-12/schema",
         type: "object",
         properties: {
-          settings: {
+          created: {
+            type: "boolean"
+          },
+          metric: {
             type: "object",
             properties: {
-              defaultTimezone: {
+              sourceKey: {
                 type: "string",
-                minLength: 1
+                pattern: "^metric_source_v1_[a-f0-9]{32}$"
+              },
+              behaviorKey: {
+                type: "string",
+                maxLength: 64,
+                pattern: "^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$"
+              },
+              label: {
+                type: "string",
+                minLength: 1,
+                maxLength: 255
+              },
+              eventSelection: {
+                oneOf: [
+                  {
+                    type: "object",
+                    properties: {
+                      mode: {
+                        type: "string",
+                        const: "exact_event_names"
+                      },
+                      eventNames: {
+                        minItems: 1,
+                        maxItems: 1,
+                        type: "array",
+                        items: {
+                          type: "string",
+                          minLength: 1,
+                          maxLength: 191
+                        }
+                      }
+                    },
+                    required: [
+                      "mode",
+                      "eventNames"
+                    ],
+                    additionalProperties: false
+                  },
+                  {
+                    type: "object",
+                    properties: {
+                      mode: {
+                        type: "string",
+                        const: "configured_event"
+                      },
+                      eventName: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 191
+                      },
+                      propertyFilters: {
+                        minItems: 1,
+                        maxItems: 5,
+                        type: "array",
+                        items: {
+                          oneOf: [
+                            {
+                              type: "object",
+                              properties: {
+                                property: {
+                                  type: "string",
+                                  minLength: 1,
+                                  maxLength: 191
+                                },
+                                operator: {
+                                  type: "string",
+                                  const: "equals"
+                                },
+                                value: {
+                                  oneOf: [
+                                    {
+                                      type: "object",
+                                      properties: {
+                                        type: {
+                                          type: "string",
+                                          const: "string"
+                                        },
+                                        value: {
+                                          type: "string",
+                                          maxLength: 191
+                                        }
+                                      },
+                                      required: [
+                                        "type",
+                                        "value"
+                                      ],
+                                      additionalProperties: false
+                                    },
+                                    {
+                                      type: "object",
+                                      properties: {
+                                        type: {
+                                          type: "string",
+                                          const: "number"
+                                        },
+                                        value: {
+                                          type: "number",
+                                          minimum: -9007199254740991,
+                                          maximum: 9007199254740991
+                                        }
+                                      },
+                                      required: [
+                                        "type",
+                                        "value"
+                                      ],
+                                      additionalProperties: false
+                                    },
+                                    {
+                                      type: "object",
+                                      properties: {
+                                        type: {
+                                          type: "string",
+                                          const: "boolean"
+                                        },
+                                        value: {
+                                          type: "boolean"
+                                        }
+                                      },
+                                      required: [
+                                        "type",
+                                        "value"
+                                      ],
+                                      additionalProperties: false
+                                    }
+                                  ]
+                                }
+                              },
+                              required: [
+                                "property",
+                                "operator",
+                                "value"
+                              ],
+                              additionalProperties: false
+                            },
+                            {
+                              type: "object",
+                              properties: {
+                                property: {
+                                  type: "string",
+                                  minLength: 1,
+                                  maxLength: 191
+                                },
+                                operator: {
+                                  type: "string",
+                                  const: "exists"
+                                }
+                              },
+                              required: [
+                                "property",
+                                "operator"
+                              ],
+                              additionalProperties: false
+                            }
+                          ]
+                        }
+                      }
+                    },
+                    required: [
+                      "mode",
+                      "eventName",
+                      "propertyFilters"
+                    ],
+                    additionalProperties: false
+                  }
+                ]
+              },
+              status: {
+                type: "string",
+                const: "ENABLED"
+              },
+              evaluationMode: {
+                type: "string",
+                const: "SHADOW"
+              },
+              definitions: {
+                minItems: 2,
+                maxItems: 2,
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    id: {
+                      type: "string",
+                      format: "uuid",
+                      pattern: "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+                    },
+                    metricKey: {
+                      type: "string",
+                      minLength: 1,
+                      maxLength: 191
+                    },
+                    aggregation: {
+                      type: "string",
+                      enum: [
+                        "active_days",
+                        "event_count"
+                      ]
+                    }
+                  },
+                  required: [
+                    "id",
+                    "metricKey",
+                    "aggregation"
+                  ],
+                  additionalProperties: false
+                }
               }
             },
             required: [
-              "defaultTimezone"
+              "sourceKey",
+              "behaviorKey",
+              "label",
+              "eventSelection",
+              "status",
+              "evaluationMode",
+              "definitions"
             ],
             additionalProperties: false
           }
         },
         required: [
-          "settings"
+          "created",
+          "metric"
         ],
         additionalProperties: false
       }
@@ -9392,11 +11024,15 @@ Returns column definitions and example queries for each view.`,
       "outlit_query",
       "outlit_schema"
     ],
-    cli: [
+    pi: [
       "outlit_list_customers",
       "outlit_list_users",
       "outlit_list_workspace_users",
       "outlit_get_customer",
+      "outlit_assign_customer_owner",
+      "outlit_grant_customer_access",
+      "outlit_update_customer_access",
+      "outlit_revoke_customer_access",
       "outlit_get_timeline",
       "outlit_list_facts",
       "outlit_get_fact",
@@ -9412,16 +11048,54 @@ Returns column definitions and example queries for each view.`,
       "outlit_enable_destination",
       "outlit_disable_destination",
       "outlit_archive_destination",
-      "outlit_list_integrations",
       "outlit_get_integration_capabilities",
       "outlit_begin_integration_setup",
       "outlit_get_integration_setup_status",
-      "outlit_get_integration_sync_status",
+      "outlit_get_integration_status",
+      "outlit_setup_integration",
       "outlit_get_customer_activation",
       "outlit_preview_customer_activation",
       "outlit_update_customer_activation",
       "outlit_get_workspace_settings",
       "outlit_update_workspace_settings"
+    ],
+    cli: [
+      "outlit_list_customers",
+      "outlit_list_users",
+      "outlit_list_workspace_users",
+      "outlit_get_customer",
+      "outlit_assign_customer_owner",
+      "outlit_grant_customer_access",
+      "outlit_update_customer_access",
+      "outlit_revoke_customer_access",
+      "outlit_get_timeline",
+      "outlit_list_facts",
+      "outlit_get_fact",
+      "outlit_get_source",
+      "outlit_list_sources",
+      "outlit_search_customer_context",
+      "outlit_query",
+      "outlit_schema",
+      "outlit_list_destinations",
+      "outlit_get_destination",
+      "outlit_create_destination",
+      "outlit_update_destination",
+      "outlit_enable_destination",
+      "outlit_disable_destination",
+      "outlit_archive_destination",
+      "outlit_get_integration_capabilities",
+      "outlit_begin_integration_setup",
+      "outlit_get_integration_setup_status",
+      "outlit_get_integration_status",
+      "outlit_setup_integration",
+      "outlit_get_customer_activation",
+      "outlit_preview_customer_activation",
+      "outlit_update_customer_activation",
+      "outlit_get_workspace_settings",
+      "outlit_update_workspace_settings",
+      "outlit_list_behavior_metric_sources",
+      "outlit_list_behavior_metric_events",
+      "outlit_create_behavior_metric"
     ]
   };
   toolGatewayTransport = {
@@ -9574,11 +11248,14 @@ Returns column definitions and example queries for each view.`,
                 "workspace_members:read",
                 "analytics:read",
                 "destinations:manage",
+                "behavior_metrics:manage",
+                "integrations:connect_own",
                 "integrations:manage",
                 "activation:read",
                 "activation:manage",
                 "workspace_settings:read",
-                "workspace_settings:manage"
+                "workspace_settings:manage",
+                "customer_access:manage"
               ]
             }
           },
@@ -9629,11 +11306,14 @@ Returns column definitions and example queries for each view.`,
                 "workspace_members:read",
                 "analytics:read",
                 "destinations:manage",
+                "behavior_metrics:manage",
+                "integrations:connect_own",
                 "integrations:manage",
                 "activation:read",
                 "activation:manage",
                 "workspace_settings:read",
-                "workspace_settings:manage"
+                "workspace_settings:manage",
+                "customer_access:manage"
               ]
             }
           }
@@ -9857,6 +11537,7 @@ Returns column definitions and example queries for each view.`,
   };
   defaultToolNames = consumerToolPolicies.default;
   analyticalToolNames = consumerToolPolicies.analytical;
+  piToolNames = consumerToolPolicies.pi;
   cliToolNames = consumerToolPolicies.cli;
   defaultToolNameSet = new Set(defaultToolNames);
   sqlToolNames = analyticalToolNames.filter((toolName) => !defaultToolNameSet.has(toolName));
@@ -9872,18 +11553,37 @@ async function createClient(flagApiKey) {
     throw new Error(`Invalid API key format. Keys must start with "ok_" followed by at least 32 alphanumeric characters. Get one at ${OUTLIT_DASHBOARD_URL}`);
   }
   const baseUrl = process.env.OUTLIT_API_URL ?? DEFAULT_API_URL;
+  validateApiBaseUrl(baseUrl);
   const toolsClient = createOutlitClient({ apiKey: credential.key, baseUrl });
   return {
     key: credential.key,
     baseUrl,
-    async callTool(toolName, params) {
+    async callTool(toolName, params, callOptions) {
       if (!isPublicToolName(toolName) || !cliToolNameSet.has(toolName)) {
         throw new Error(`Unknown CLI tool: ${toolName}`);
       }
-      return toolsClient.callTool(toolName, params);
+      return toolsClient.callTool(toolName, params, {
+        signal: callOptions?.signal
+      });
     }
   };
 }
+function validateApiBaseUrl(baseUrl) {
+  let url;
+  try {
+    url = new URL(baseUrl);
+  } catch {
+    throw new Error("OUTLIT_API_URL must be a valid absolute URL");
+  }
+  if (url.protocol === "https:" || url.protocol === "http:" && isLoopbackHost(url.hostname)) {
+    return;
+  }
+  throw new Error("OUTLIT_API_URL must use HTTPS unless it is a loopback development URL");
+}
+function isLoopbackHost(hostname) {
+  const normalized = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  return normalized === "localhost" || normalized === "::1" || /^127(?:\.\d{1,3}){3}$/.test(normalized);
+}
 var API_KEY_REGEX, cliToolNameSet;
 var init_client = __esm(() => {
   init_dist4();
@@ -10066,6 +11766,17 @@ async function validateKeyOrExit(apiKey, json) {
     }, json);
   }
 }
+function outputApiError(error, json, fallback) {
+  if (isOutlitToolsApiError(error) && error.envelope) {
+    if (isJsonMode(json)) {
+      process.stderr.write(`${JSON.stringify(error.envelope, null, 2)}
+`);
+      process.exit(1);
+    }
+    return outputError({ message: error.envelope.message, code: error.envelope.code }, json);
+  }
+  return outputError(fallback, json);
+}
 function renderApiTable(data, table) {
   const record = typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
   const itemsKey = table.itemsKey ?? "items";
@@ -10100,7 +11811,7 @@ function readPath(record, path) {
   return current;
 }
 async function runTool(client, toolName, params, json, opts) {
-  const spinner = opts?.spinnerMessage ? createSpinner(opts.spinnerMessage) : null;
+  const spinner = opts?.spinnerMessage && !isJsonMode(json) ? createSpinner(opts.spinnerMessage) : null;
   try {
     const rawData = await client.callTool(toolName, params);
     const data = opts?.transform ? opts.transform(rawData) : rawData;
@@ -10112,15 +11823,10 @@ async function runTool(client, toolName, params, json, opts) {
     renderApiTable(data, table);
   } catch (err) {
     spinner?.fail("Failed");
-    if (isOutlitToolsApiError(err) && err.envelope) {
-      if (isJsonMode(json)) {
-        process.stderr.write(`${JSON.stringify(err.envelope, null, 2)}
-`);
-        process.exit(1);
-      }
-      return outputError({ message: err.envelope.message, code: err.envelope.code }, json);
-    }
-    return outputError({ message: errorMessage(err, "Request failed"), code: "api_error" }, json);
+    return outputApiError(err, json, {
+      message: errorMessage(err, "Request failed"),
+      code: "api_error"
+    });
   }
 }
 var ApiKeyValidationUnavailableError;
@@ -10146,16 +11852,26 @@ async function pollUntil(fn, predicate, opts = {}) {
   const timeoutMs = opts.timeoutMs ?? 300000;
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
+    const remainingMs = timeoutMs - (Date.now() - start);
+    const controller = new AbortController;
+    const deadline = setTimeout(() => controller.abort(), remainingMs);
     try {
-      const result = await fn();
+      const result = await fn(controller.signal);
       if (predicate(result))
         return result;
-    } catch {}
+    } catch (error) {
+      if (controller.signal.aborted && Date.now() - start >= timeoutMs)
+        return null;
+      if (opts.shouldRetry?.(error) === false)
+        throw error;
+    } finally {
+      clearTimeout(deadline);
+    }
     if (opts.spinner && opts.spinnerMessage) {
       const elapsed = Math.floor((Date.now() - start) / 1000);
       opts.spinner.update(`${opts.spinnerMessage} (${elapsed}s)`);
     }
-    await sleep(intervalMs);
+    await sleep(Math.min(intervalMs, Math.max(0, timeoutMs - (Date.now() - start))));
   }
   return null;
 }
@@ -11115,27 +12831,33 @@ function capitalize(value) {
     return "--";
   return value.charAt(0).toUpperCase() + value.slice(1);
 }
-function formatNumber(value) {
-  if (value == null || typeof value !== "number" || Number.isNaN(value))
-    return "--";
-  return value.toLocaleString("en-US");
-}
 
 // src/lib/platform-input.ts
 function isIso8601DateTime(value) {
   return iso8601DateTimeRegex.test(value) && !Number.isNaN(new Date(value).getTime());
 }
 function requiredTrimmedString(value, flag, json) {
-  const trimmed = value?.trim();
-  if (!trimmed) {
+  return requiredString(value, flag, json).trim();
+}
+function requiredString(value, flag, json) {
+  if (!value?.trim()) {
     return outputError({ message: `Provide ${flag}`, code: "missing_input" }, json);
   }
-  return trimmed;
+  return value;
 }
 function optionalTrimmedString(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : null;
 }
+function parseIntegerFlag(value, fallback, flag, json) {
+  if (value === undefined)
+    return fallback;
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isInteger(parsed)) {
+    return outputError({ message: `${flag} must be an integer`, code: "invalid_input" }, json);
+  }
+  return parsed;
+}
 var iso8601DateTimeRegex;
 var init_platform_input = __esm(() => {
   init_output();
@@ -11424,25 +13146,279 @@ var init_timeline = __esm(() => {
   };
   timeline_default = defineCommand2({
     meta: {
-      name: "timeline",
+      name: "timeline",
+      description: [
+        "Show the activity timeline for a customer.",
+        "",
+        "The customer argument accepts:",
+        "  - Customer domain (acme.com)",
+        "  - Customer ID (UUID)",
+        "",
+        "Timeframe is used when no explicit date range is set.",
+        "When --start-date or --end-date is provided, --timeframe is ignored.",
+        `Channels: ${timelineChannels.join(", ")}`,
+        `Timeframes: ${timelineTimeframes.join(", ")}`,
+        "",
+        "Examples:",
+        "  outlit customers timeline acme.com",
+        "  outlit customers timeline acme.com --timeframe 90d",
+        "  outlit customers timeline acme.com --channels COMMUNICATION,MEETING",
+        "  outlit customers timeline acme.com --start-date 2025-01-01T00:00:00Z --end-date 2025-03-01T23:59:59Z",
+        "  outlit customers timeline acme.com --event-types PAGE_VIEW,MEETING --limit 50",
+        "",
+        AGENT_JSON_HINT
+      ].join(`
+`)
+    },
+    args: {
+      ...authArgs,
+      ...outputArgs,
+      ...paginationArgs,
+      customer: {
+        type: "positional",
+        description: "Customer ID or domain (acme.com)",
+        required: true
+      },
+      channels: {
+        type: "string",
+        description: `Comma-separated list of channels to filter (${timelineChannels.join(", ")})`
+      },
+      "event-types": {
+        type: "string",
+        description: "Comma-separated list of event types to filter (e.g. PAGE_VIEW,MEETING)"
+      },
+      timeframe: {
+        type: "string",
+        description: `Timeframe for events (${timelineTimeframes.join(", ")}). Ignored when --start-date or --end-date is set.`,
+        default: "30d"
+      },
+      "start-date": {
+        type: "string",
+        description: "Start datetime for the event range (ISO 8601, e.g. 2025-01-01T00:00:00Z). When set, --timeframe is ignored."
+      },
+      "end-date": {
+        type: "string",
+        description: "End datetime for the event range (ISO 8601, e.g. 2025-03-01T23:59:59Z). When set, --timeframe is ignored."
+      }
+    },
+    async run({ args }) {
+      const json = !!args.json;
+      const client = await getClientOrExit(args["api-key"], json);
+      const hasDateRange = !!args["start-date"] || !!args["end-date"];
+      const params = { customer: args.customer };
+      if (hasDateRange) {
+        if (args["start-date"])
+          params.startDate = args["start-date"];
+        if (args["end-date"])
+          params.endDate = args["end-date"];
+      } else {
+        params.timeframe = args.timeframe;
+      }
+      if (args.channels) {
+        params.channels = normalizeTimelineChannels(args.channels);
+      }
+      if (args["event-types"]) {
+        params.eventTypes = splitCsv(args["event-types"]);
+      }
+      applyPagination(params, args, json);
+      return runTool(client, publicToolContracts.outlit_get_timeline.toolName, params, json);
+    }
+  });
+});
+
+// src/commands/customers/collaboration-input.ts
+function parseCustomerCollaborationIds(args, json) {
+  const customerId = requiredString(args["customer-id"], "<customer-id>", json);
+  const customerIdPattern = new RegExp(customerIdSchema.pattern);
+  if (!customerIdPattern.test(customerId)) {
+    return outputError({ message: "<customer-id> must be an exact customer UUID", code: "invalid_input" }, json);
+  }
+  const targetUserId = requiredString(args["target-user-id"], "--target-user-id", json);
+  if (targetUserId.length > targetUserIdSchema.maxLength) {
+    return outputError({
+      message: `--target-user-id must be at most ${targetUserIdSchema.maxLength} characters`,
+      code: "invalid_input"
+    }, json);
+  }
+  return { customerId, targetUserId };
+}
+function parseCustomerAccessRole(value, json) {
+  const input = requiredString(value, "--role", json);
+  const role = customerAccessRoles.find((candidate) => candidate === input);
+  if (!role) {
+    return outputError({
+      message: `--role must be one of: ${customerAccessRoles.join(", ")}`,
+      code: "invalid_input"
+    }, json);
+  }
+  return role;
+}
+var customerIdSchema, targetUserIdSchema, customerAccessRoles, customerCollaborationIdArgs, customerAccessRoleArg;
+var init_collaboration_input = __esm(() => {
+  init_dist4();
+  init_output();
+  init_platform_input();
+  customerIdSchema = publicToolContracts.outlit_assign_customer_owner.inputSchema.properties.customerId;
+  targetUserIdSchema = publicToolContracts.outlit_assign_customer_owner.inputSchema.properties.targetUserId;
+  customerAccessRoles = publicToolContracts.outlit_grant_customer_access.inputSchema.properties.role.enum;
+  customerCollaborationIdArgs = {
+    "customer-id": {
+      type: "positional",
+      description: "Exact customer UUID",
+      required: true
+    },
+    "target-user-id": {
+      type: "string",
+      description: "Required exact workspace-user ID from `outlit ws-users list --json`"
+    }
+  };
+  customerAccessRoleArg = {
+    role: {
+      type: "string",
+      description: `Required collaboration role (${customerAccessRoles.join(", ")})`
+    }
+  };
+});
+
+// src/commands/customers/owner/set.ts
+var exports_set = {};
+__export(exports_set, {
+  default: () => set_default
+});
+var set_default;
+var init_set = __esm(() => {
+  init_dist4();
+  init_dist();
+  init_auth();
+  init_output2();
+  init_api();
+  init_collaboration_input();
+  set_default = defineCommand2({
+    meta: {
+      name: "set",
+      description: [
+        "Assign an active workspace member as a customer's primary owner.",
+        "The former owner keeps Editor access.",
+        "Both IDs must be exact; discover them with customer and workspace-user list commands.",
+        "",
+        "Example:",
+        "  outlit customers owner set 10000000-0000-4000-8000-000000000000 --target-user-id user_123 --json",
+        "",
+        AGENT_JSON_HINT
+      ].join(`
+`)
+    },
+    args: {
+      ...authArgs,
+      ...outputArgs,
+      ...customerCollaborationIdArgs
+    },
+    async run({ args }) {
+      const json = !!args.json;
+      const input = parseCustomerCollaborationIds(args, json);
+      const client = await getClientOrExit(args["api-key"], json);
+      return runTool(client, publicToolContracts.outlit_assign_customer_owner.toolName, input, json, {
+        spinnerMessage: "Assigning customer owner..."
+      });
+    }
+  });
+});
+
+// src/commands/customers/owner/index.ts
+var exports_owner = {};
+__export(exports_owner, {
+  default: () => owner_default
+});
+var owner_default;
+var init_owner = __esm(() => {
+  init_dist();
+  init_output2();
+  owner_default = defineCommand2({
+    meta: {
+      name: "owner",
+      description: [
+        "Manage a customer's primary owner.",
+        "",
+        "Commands:",
+        "  set -- assign or reassign the primary owner",
+        "",
+        AGENT_JSON_HINT
+      ].join(`
+`)
+    },
+    subCommands: {
+      set: () => Promise.resolve().then(() => (init_set(), exports_set)).then((m) => m.default)
+    }
+  });
+});
+
+// src/commands/customers/grant.ts
+var exports_grant = {};
+__export(exports_grant, {
+  default: () => grant_default
+});
+var grant_default;
+var init_grant = __esm(() => {
+  init_dist4();
+  init_dist();
+  init_auth();
+  init_output2();
+  init_api();
+  init_collaboration_input();
+  grant_default = defineCommand2({
+    meta: {
+      name: "grant",
+      description: [
+        "Grant or change Viewer or Editor customer access for an active workspace member.",
+        "Re-run this command with a different role to update an existing collaborator.",
+        "Both IDs must be exact; discover them with customer and workspace-user list commands.",
+        "",
+        "Example:",
+        "  outlit customers grant 10000000-0000-4000-8000-000000000000 --target-user-id user_123 --role VIEWER --json",
+        "",
+        AGENT_JSON_HINT
+      ].join(`
+`)
+    },
+    args: {
+      ...authArgs,
+      ...outputArgs,
+      ...customerCollaborationIdArgs,
+      ...customerAccessRoleArg
+    },
+    async run({ args }) {
+      const json = !!args.json;
+      const ids = parseCustomerCollaborationIds(args, json);
+      const role = parseCustomerAccessRole(args.role, json);
+      const client = await getClientOrExit(args["api-key"], json);
+      return runTool(client, publicToolContracts.outlit_grant_customer_access.toolName, { ...ids, role }, json, { spinnerMessage: "Granting customer access..." });
+    }
+  });
+});
+
+// src/commands/customers/revoke.ts
+var exports_revoke = {};
+__export(exports_revoke, {
+  default: () => revoke_default
+});
+var revoke_default;
+var init_revoke = __esm(() => {
+  init_dist4();
+  init_dist();
+  init_auth();
+  init_output2();
+  init_api();
+  init_collaboration_input();
+  revoke_default = defineCommand2({
+    meta: {
+      name: "revoke",
       description: [
-        "Show the activity timeline for a customer.",
-        "",
-        "The customer argument accepts:",
-        "  - Customer domain (acme.com)",
-        "  - Customer ID (UUID)",
-        "",
-        "Timeframe is used when no explicit date range is set.",
-        "When --start-date or --end-date is provided, --timeframe is ignored.",
-        `Channels: ${timelineChannels.join(", ")}`,
-        `Timeframes: ${timelineTimeframes.join(", ")}`,
+        "Remove a collaborator's explicit access to a customer.",
+        "The primary owner cannot be removed.",
+        "Both IDs must be exact; discover them with customer and workspace-user list commands.",
         "",
-        "Examples:",
-        "  outlit customers timeline acme.com",
-        "  outlit customers timeline acme.com --timeframe 90d",
-        "  outlit customers timeline acme.com --channels COMMUNICATION,MEETING",
-        "  outlit customers timeline acme.com --start-date 2025-01-01T00:00:00Z --end-date 2025-03-01T23:59:59Z",
-        "  outlit customers timeline acme.com --event-types PAGE_VIEW,MEETING --limit 50",
+        "Example:",
+        "  outlit customers revoke 10000000-0000-4000-8000-000000000000 --target-user-id user_123 --json",
         "",
         AGENT_JSON_HINT
       ].join(`
@@ -11451,55 +13427,13 @@ var init_timeline = __esm(() => {
     args: {
       ...authArgs,
       ...outputArgs,
-      ...paginationArgs,
-      customer: {
-        type: "positional",
-        description: "Customer ID or domain (acme.com)",
-        required: true
-      },
-      channels: {
-        type: "string",
-        description: `Comma-separated list of channels to filter (${timelineChannels.join(", ")})`
-      },
-      "event-types": {
-        type: "string",
-        description: "Comma-separated list of event types to filter (e.g. PAGE_VIEW,MEETING)"
-      },
-      timeframe: {
-        type: "string",
-        description: `Timeframe for events (${timelineTimeframes.join(", ")}). Ignored when --start-date or --end-date is set.`,
-        default: "30d"
-      },
-      "start-date": {
-        type: "string",
-        description: "Start datetime for the event range (ISO 8601, e.g. 2025-01-01T00:00:00Z). When set, --timeframe is ignored."
-      },
-      "end-date": {
-        type: "string",
-        description: "End datetime for the event range (ISO 8601, e.g. 2025-03-01T23:59:59Z). When set, --timeframe is ignored."
-      }
+      ...customerCollaborationIdArgs
     },
     async run({ args }) {
       const json = !!args.json;
+      const input = parseCustomerCollaborationIds(args, json);
       const client = await getClientOrExit(args["api-key"], json);
-      const hasDateRange = !!args["start-date"] || !!args["end-date"];
-      const params = { customer: args.customer };
-      if (hasDateRange) {
-        if (args["start-date"])
-          params.startDate = args["start-date"];
-        if (args["end-date"])
-          params.endDate = args["end-date"];
-      } else {
-        params.timeframe = args.timeframe;
-      }
-      if (args.channels) {
-        params.channels = normalizeTimelineChannels(args.channels);
-      }
-      if (args["event-types"]) {
-        params.eventTypes = splitCsv(args["event-types"]);
-      }
-      applyPagination(params, args, json);
-      return runTool(client, publicToolContracts.outlit_get_timeline.toolName, params, json);
+      return runTool(client, publicToolContracts.outlit_revoke_customer_access.toolName, input, json, { spinnerMessage: "Revoking customer access..." });
     }
   });
 });
@@ -11523,6 +13457,9 @@ var init_customers = __esm(() => {
         "  list      -- list customers with filters",
         "  get       -- get a specific customer by ID or domain",
         "  timeline  -- show activity timeline for a customer",
+        "  owner set -- assign a primary customer owner",
+        "  grant     -- grant or change Viewer or Editor access",
+        "  revoke    -- remove explicit collaborator access",
         "",
         AGENT_JSON_HINT
       ].join(`
@@ -11531,7 +13468,10 @@ var init_customers = __esm(() => {
     subCommands: {
       list: () => Promise.resolve().then(() => (init_list(), exports_list)).then((m) => m.default),
       get: () => Promise.resolve().then(() => (init_get2(), exports_get2)).then((m) => m.default),
-      timeline: () => Promise.resolve().then(() => (init_timeline(), exports_timeline)).then((m) => m.default)
+      timeline: () => Promise.resolve().then(() => (init_timeline(), exports_timeline)).then((m) => m.default),
+      owner: () => Promise.resolve().then(() => (init_owner(), exports_owner)).then((m) => m.default),
+      grant: () => Promise.resolve().then(() => (init_grant(), exports_grant)).then((m) => m.default),
+      revoke: () => Promise.resolve().then(() => (init_revoke(), exports_revoke)).then((m) => m.default)
     }
   });
 });
@@ -11696,9 +13636,10 @@ var init_list3 = __esm(() => {
     meta: {
       name: "list",
       description: [
-        "List and filter internal workspace users.",
+        "List all active workspace members with local Outlit user records.",
         "",
-        "Use this to discover CSMs, managers, and account owners before composing dynamic customer reports.",
+        "By default, customer ownership does not limit results; --has-owned-customers is the only customer-related filter.",
+        "Use JSON output to copy exact user IDs for customer ownership and access commands.",
         "Output is JSON when piped or when --json is passed.",
         "",
         "Examples:",
@@ -11729,7 +13670,7 @@ var init_list3 = __esm(() => {
       },
       "has-owned-customers": {
         type: "boolean",
-        description: "Return only workspace users who own at least one customer"
+        description: "Return only members who own customers; omit for all eligible members"
       }
     },
     async run({ args }) {
@@ -11999,14 +13940,14 @@ async function checkIntegrationReadiness(apiKey, checks) {
       status: "pass",
       message: `${providers.length} provider setup capabilities available`
     });
-    const integrations = await client.callTool("outlit_list_integrations", {});
+    const integrations = await client.callTool("outlit_get_integration_status", {});
     const items = Array.isArray(integrations.integrations) ? integrations.integrations : [];
-    summary.connectedCount = items.filter((item) => item.status === "connected").length;
-    summary.errorCount = items.filter((item) => item.status === "error").length;
+    summary.connectedCount = items.filter((item) => item.status === "ready").length;
+    summary.errorCount = items.filter((item) => item.status === "requires_intervention").length;
     checks.push({
       name: "Integrations",
       status: summary.errorCount > 0 ? "warn" : "pass",
-      message: summary.errorCount > 0 ? `${summary.connectedCount} connected, ${summary.errorCount} with errors` : `${summary.connectedCount} connected`
+      message: summary.errorCount > 0 ? `${summary.connectedCount} ready, ${summary.errorCount} requiring intervention` : `${summary.connectedCount} ready`
     });
   } catch (err) {
     checks.push({
@@ -12020,7 +13961,6 @@ async function checkIntegrationReadiness(apiKey, checks) {
 function buildNextActions() {
   return [
     "outlit doctor --json",
-    "outlit integrations capabilities --json",
     "outlit integrations setup <provider> --json",
     "outlit integrations status --json"
   ];
@@ -12058,7 +13998,7 @@ var init_onboard = __esm(() => {
         "Examples:",
         "  outlit onboard --agent codex --json",
         "  outlit auth login --browser --json",
-        "  outlit integrations capabilities --json",
+        "  outlit integrations setup <provider> --json",
         "",
         AGENT_JSON_HINT
       ].join(`
@@ -12677,39 +14617,39 @@ async function checkIntegrations(apiKey) {
     const client = await createClient(apiKey);
     const timeout = new Promise((_2, reject) => setTimeout(() => reject(new Error("Integrations check timed out")), 1e4));
     const data = await Promise.race([
-      client.callTool("outlit_list_integrations", {}),
+      client.callTool("outlit_get_integration_status", {}),
       timeout
     ]);
-    const items = data.items ?? [];
-    const connected = items.filter((i) => i.status === "connected").length;
-    const errors = items.filter((i) => i.status === "error").length;
-    if (errors > 0) {
+    const items = data.integrations ?? [];
+    const ready = items.filter((item) => item.status === "ready").length;
+    const requiringIntervention = items.filter((item) => item.status === "requires_intervention").length;
+    if (requiringIntervention > 0) {
       return {
         name: "Integrations",
         status: "warn",
-        message: `${connected} connected, ${errors} with errors`,
+        message: `${ready} ready, ${requiringIntervention} requiring intervention`,
         detail: "Run `outlit integrations status` for details"
       };
     }
-    if (connected === 0) {
+    if (ready === 0) {
       return {
         name: "Integrations",
         status: "pass",
-        message: "No integrations connected",
-        detail: "Run `outlit integrations list` to see available integrations"
+        message: "No integrations ready",
+        detail: "Run `outlit integrations status` to inspect integrations"
       };
     }
     return {
       name: "Integrations",
       status: "pass",
-      message: `${connected} integration(s) connected`
+      message: `${ready} integration(s) ready`
     };
   } catch {
     return {
       name: "Integrations",
       status: "warn",
       message: "Could not check integrations",
-      detail: "Integration status endpoint may not be available yet"
+      detail: "Integration readiness may not be available yet"
     };
   }
 }
@@ -13308,7 +15248,7 @@ var init_list5 = __esm(() => {
       description: [
         "List concrete source records deterministically.",
         "",
-        "Use this when you need enumerated calls, emails, calendar events, support tickets, or opportunities rather than semantic ranking.",
+        "Use this when you need enumerated calls, emails, calendar events, support tickets, opportunities, or Slack conversations rather than semantic ranking.",
         "",
         "Examples:",
         "  outlit sources list --customer acme.com --source-type CALL",
@@ -14192,6 +16132,202 @@ var init_destinations = __esm(() => {
   });
 });
 
+// src/commands/metrics/sources.ts
+var exports_sources2 = {};
+__export(exports_sources2, {
+  default: () => sources_default2
+});
+var sources_default2;
+var init_sources2 = __esm(() => {
+  init_dist();
+  init_auth();
+  init_output2();
+  init_api();
+  sources_default2 = defineCommand2({
+    meta: {
+      name: "sources",
+      description: [
+        "List product-event sources eligible for Behavior Metrics.",
+        "",
+        "Use the returned source key with `outlit metrics events --source <source-key>`.",
+        "",
+        AGENT_JSON_HINT
+      ].join(`
+`)
+    },
+    args: { ...authArgs, ...outputArgs },
+    async run({ args }) {
+      const json = !!args.json;
+      const client = await getClientOrExit(args["api-key"], json);
+      return runTool(client, "outlit_list_behavior_metric_sources", {}, json, {
+        spinnerMessage: "Loading Behavior Metric sources..."
+      });
+    }
+  });
+});
+
+// src/commands/metrics/events.ts
+var exports_events = {};
+__export(exports_events, {
+  default: () => events_default
+});
+function parseBoundedInteger2(value, fallback, flag, min, max, json) {
+  const parsed = parseIntegerFlag(value, fallback, flag, json);
+  if (parsed < min || parsed > max) {
+    return outputError({ message: `${flag} must be an integer from ${min} to ${max}`, code: "invalid_input" }, json);
+  }
+  return parsed;
+}
+var events_default;
+var init_events = __esm(() => {
+  init_dist();
+  init_auth();
+  init_output2();
+  init_api();
+  init_output();
+  init_platform_input();
+  events_default = defineCommand2({
+    meta: {
+      name: "events",
+      description: [
+        "List attributed event candidates for a Behavior Metric source.",
+        "",
+        "Examples:",
+        "  outlit metrics events --source metric_source_v1_0123456789abcdef0123456789abcdef --json",
+        "  outlit metrics events --source metric_source_v1_0123456789abcdef0123456789abcdef --weeks 4 --limit 20 --json",
+        "",
+        AGENT_JSON_HINT
+      ].join(`
+`)
+    },
+    args: {
+      ...authArgs,
+      ...outputArgs,
+      source: { type: "string", description: "Behavior Metric source key" },
+      weeks: { type: "string", description: "History window in weeks (1-53, default: 12)" },
+      limit: { type: "string", description: "Maximum event candidates (1-100, default: 100)" }
+    },
+    async run({ args }) {
+      const json = !!args.json;
+      const client = await getClientOrExit(args["api-key"], json);
+      return runTool(client, "outlit_list_behavior_metric_events", {
+        sourceKey: requiredTrimmedString(args.source, "--source", json),
+        weeks: parseBoundedInteger2(args.weeks, 12, "--weeks", 1, 53, json),
+        limit: parseBoundedInteger2(args.limit, 100, "--limit", 1, 100, json)
+      }, json, { spinnerMessage: "Loading Behavior Metric events..." });
+    }
+  });
+});
+
+// src/commands/metrics/create.ts
+var exports_create2 = {};
+__export(exports_create2, {
+  default: () => create_default2
+});
+function parsePropertyFilters(value, json) {
+  if (!value?.trim())
+    return [];
+  try {
+    const parsed = JSON.parse(value);
+    if (!Array.isArray(parsed)) {
+      return outputError({ message: "--property-filters must be a JSON array", code: "invalid_input" }, json);
+    }
+    return parsed;
+  } catch (error) {
+    return outputError({
+      message: `Invalid --property-filters JSON: ${errorMessage(error, "parse failed")}`,
+      code: "invalid_input"
+    }, json);
+  }
+}
+var create_default2;
+var init_create2 = __esm(() => {
+  init_dist();
+  init_auth();
+  init_output2();
+  init_api();
+  init_output();
+  init_platform_input();
+  create_default2 = defineCommand2({
+    meta: {
+      name: "create",
+      description: [
+        "Create an event-based Outlit Behavior Metric.",
+        "",
+        "Examples:",
+        "  outlit metrics create --source metric_source_v1_0123456789abcdef0123456789abcdef --event report_exported --key reports_exported --label 'Reports exported' --json",
+        `  outlit metrics create --source metric_source_v1_0123456789abcdef0123456789abcdef --event report_exported --key production_reports_exported --label 'Production reports exported' --property-filters '[{"property":"environment","operator":"equals","value":{"type":"string","value":"production"}}]' --json`,
+        "",
+        AGENT_JSON_HINT
+      ].join(`
+`)
+    },
+    args: {
+      ...authArgs,
+      ...outputArgs,
+      source: { type: "string", description: "Behavior Metric source key" },
+      event: { type: "string", description: "Exact tracked event name" },
+      key: { type: "string", description: "Stable lower_snake_case metric key" },
+      label: { type: "string", description: "Human-readable metric label" },
+      "property-filters": {
+        type: "string",
+        description: "Optional JSON array of event property filters"
+      }
+    },
+    async run({ args }) {
+      const json = !!args.json;
+      const client = await getClientOrExit(args["api-key"], json);
+      const input = {
+        sourceKey: requiredTrimmedString(args.source, "--source", json),
+        eventName: requiredString(args.event, "--event", json),
+        behaviorKey: requiredTrimmedString(args.key, "--key", json),
+        label: requiredTrimmedString(args.label, "--label", json),
+        propertyFilters: parsePropertyFilters(args["property-filters"], json)
+      };
+      return runTool(client, "outlit_create_behavior_metric", input, json, {
+        spinnerMessage: "Creating Behavior Metric..."
+      });
+    }
+  });
+});
+
+// src/commands/metrics/index.ts
+var exports_metrics = {};
+__export(exports_metrics, {
+  default: () => metrics_default
+});
+var metrics_default;
+var init_metrics = __esm(() => {
+  init_dist();
+  init_output2();
+  metrics_default = defineCommand2({
+    meta: {
+      name: "metrics",
+      description: [
+        "Configure event-based Outlit Behavior Metrics.",
+        "",
+        "Commands:",
+        "  sources                       List eligible event sources",
+        "  events                        List event candidates for a source",
+        "  create                        Create a Behavior Metric",
+        "",
+        "Examples:",
+        "  outlit metrics sources --json",
+        "  outlit metrics events --source metric_source_v1_0123456789abcdef0123456789abcdef --json",
+        "  outlit metrics create --source metric_source_v1_0123456789abcdef0123456789abcdef --event report_exported --key reports_exported --label 'Reports exported' --json",
+        "",
+        AGENT_JSON_HINT
+      ].join(`
+`)
+    },
+    subCommands: {
+      sources: () => Promise.resolve().then(() => (init_sources2(), exports_sources2)).then((module) => module.default),
+      events: () => Promise.resolve().then(() => (init_events(), exports_events)).then((module) => module.default),
+      create: () => Promise.resolve().then(() => (init_create2(), exports_create2)).then((module) => module.default)
+    }
+  });
+});
+
 // src/commands/settings/get.ts
 var exports_get6 = {};
 __export(exports_get6, {
@@ -14309,183 +16445,564 @@ var init_settings = __esm(() => {
   });
 });
 
-// src/commands/integrations/list.ts
-var exports_list7 = {};
-__export(exports_list7, {
-  default: () => list_default7
-});
-var list_default7;
-var init_list7 = __esm(() => {
-  init_dist();
-  init_auth();
-  init_output2();
-  init_api();
-  list_default7 = defineCommand2({
-    meta: {
-      name: "list",
-      description: [
-        "List available integrations and their connection status.",
-        "",
-        "Shows all supported third-party integrations with whether they",
-        "are connected, available, or in an error state.",
-        "",
-        "Examples:",
-        "  outlit integrations list",
-        "  outlit integrations list --json",
-        "",
-        AGENT_JSON_HINT
-      ].join(`
-`)
-    },
-    args: {
-      ...authArgs,
-      ...outputArgs
-    },
-    async run({ args }) {
-      const json = !!args.json;
-      const client = await getClientOrExit(args["api-key"], json);
-      return runTool(client, "outlit_list_integrations", {}, json, {
-        spinnerMessage: "Fetching integrations...",
-        table: {
-          itemsKey: "integrations",
-          columns: [
-            { header: "Name", key: "name", format: (v) => truncate(v, 24) },
-            { header: "Category", key: "category", format: capitalize },
-            { header: "Status", key: "status" },
-            { header: "Last Synced", key: "lastDataReceivedAt", format: relativeDate }
-          ]
-        }
-      });
-    }
-  });
-});
-
 // src/lib/providers.ts
 function normalizeProviderInput(input) {
-  return input.trim().toLowerCase().replace(/[\s_]+/g, "-");
+  const normalized = input.trim().toLowerCase().replace(/[\s_]+/g, "-");
+  return normalized === "gmail" ? "google-mail" : normalized;
 }
 
-// src/commands/integrations/capabilities.ts
-var exports_capabilities = {};
-__export(exports_capabilities, {
-  default: () => capabilities_default
-});
-var capabilities_default;
-var init_capabilities = __esm(() => {
-  init_dist();
-  init_auth();
-  init_output2();
-  init_api();
-  capabilities_default = defineCommand2({
-    meta: {
-      name: "capabilities",
-      description: [
-        "Show machine-readable integration setup capabilities.",
-        "",
-        "Use this before setup to learn whether a safe browser handoff is available",
-        "or configuration must continue in the Outlit web app.",
-        "",
-        "Examples:",
-        "  outlit integrations capabilities --json",
-        "  outlit integrations capabilities hubspot --json",
-        "",
-        AGENT_JSON_HINT
-      ].join(`
-`)
-    },
-    args: {
-      ...authArgs,
-      ...outputArgs,
-      provider: {
-        type: "positional",
-        description: "Provider name to inspect (optional)",
-        required: false
-      }
-    },
-    async run({ args }) {
-      const json = !!args.json;
-      const client = await getClientOrExit(args["api-key"], json);
-      if (args.provider) {
-        return runTool(client, "outlit_get_integration_capabilities", { provider: normalizeProviderInput(args.provider) }, json, {
-          spinnerMessage: "Fetching integration capabilities..."
-        });
+// src/commands/integrations/setup-input.ts
+async function readSetupConfigText() {
+  return Bun.stdin.text();
+}
+function parseSetupConfig(text, provider) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new SetupInputError("--config-stdin requires exactly one valid JSON document.");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new SetupInputError("--config-stdin must contain a JSON object.");
+  }
+  const config = parsed;
+  const allowedKeys = new Set(["connectionMode", "credentials", "configuration"]);
+  if (Object.keys(config).some((key) => !allowedKeys.has(key))) {
+    throw new SetupInputError("--config-stdin accepts only connectionMode, credentials, and configuration.");
+  }
+  const input = { provider, ...config };
+  const schema = publicToolContracts.outlit_setup_integration.inputSchema;
+  if (!matchesGeneratedJsonSchema(input, schema)) {
+    throw new SetupInputError("--config-stdin does not match this provider's setup contract.");
+  }
+  return input;
+}
+function hasCrmConfiguration(input) {
+  const configuration = input.configuration;
+  return typeof configuration === "object" && configuration !== null && !Array.isArray(configuration) && configuration.kind === "crm_mapping";
+}
+async function collectProviderCredentials(provider) {
+  switch (provider) {
+    case "stripe":
+      return {
+        provider,
+        connectionMode: "restricted_key",
+        credentials: { apiKey: await secret("Stripe restricted API key") }
+      };
+    case "granola": {
+      const authScope = await choice("Granola key scope", [
+        { value: "personal", label: "Personal" },
+        { value: "enterprise", label: "Enterprise" }
+      ]);
+      const enterpriseKeyAcknowledged = authScope === "enterprise" ? await confirmation("I confirm this is an enterprise Granola key") : false;
+      if (authScope === "enterprise" && !enterpriseKeyAcknowledged) {
+        throw new SetupCancelledError;
       }
-      return runTool(client, "outlit_get_integration_capabilities", {}, json, {
-        spinnerMessage: "Fetching integration capabilities..."
-      });
+      return {
+        provider,
+        credentials: {
+          apiKey: await secret("Granola API key"),
+          authScope,
+          enterpriseKeyAcknowledged
+        }
+      };
     }
+    case "fireflies":
+      return { provider, credentials: { apiKey: await secret("Fireflies API key") } };
+    case "pylon":
+      return { provider, credentials: { apiToken: await secret("Pylon API token") } };
+    case "mixpanel":
+      return {
+        provider,
+        credentials: {
+          username: await visible("Mixpanel service-account username"),
+          secret: await secret("Mixpanel service-account secret"),
+          projectId: await visible("Mixpanel project ID"),
+          region: await choice("Mixpanel region", [
+            { value: "us", label: "US" },
+            { value: "eu", label: "EU" },
+            { value: "in", label: "India" }
+          ])
+        }
+      };
+    case "posthog":
+      return {
+        provider,
+        credentials: {
+          apiKey: await secret("PostHog personal API key"),
+          projectId: await visible("PostHog project ID"),
+          region: await choice("PostHog region", [
+            { value: "us", label: "US" },
+            { value: "eu", label: "EU" }
+          ])
+        }
+      };
+    default:
+      throw new SetupInputError("Core requested credentials for a provider without a CLI credential contract.", "INVALID_SETUP_RESPONSE");
+  }
+}
+async function confirmCrmRecommendation() {
+  return confirmation("Apply this exact CRM stage mapping?");
+}
+async function collectMixpanelMapping(candidateKeys) {
+  const mode = await choice("How should Mixpanel events map to Outlit customers?", [
+    { value: "group_key", label: "Mixpanel group key" },
+    { value: "event_property", label: "Event property" },
+    { value: "email_domain", label: "Email domain" }
+  ]);
+  if (mode === "email_domain")
+    return { mode };
+  if (mode === "event_property") {
+    return { mode, propertyName: await visible("Mixpanel event property") };
+  }
+  const groupKey = candidateKeys.length > 0 ? await choice("Mixpanel group key", candidateKeys.map(({ key }) => ({ value: key, label: key }))) : await visible("Mixpanel group key");
+  return { mode, groupKey };
+}
+async function secret(message) {
+  const value = await He({
+    message,
+    validate: (input) => input?.trim() ? undefined : "A value is required"
   });
+  if (Ct(value))
+    throw new SetupCancelledError;
+  return String(value).trim();
+}
+async function visible(message) {
+  const value = await Ze({
+    message,
+    validate: (input) => input?.trim() ? undefined : "A value is required"
+  });
+  if (Ct(value))
+    throw new SetupCancelledError;
+  return String(value).trim();
+}
+async function choice(message, options) {
+  const value = await Je({ message, options });
+  if (Ct(value))
+    throw new SetupCancelledError;
+  return value;
+}
+async function confirmation(message) {
+  const value = await Re({ message });
+  if (Ct(value))
+    throw new SetupCancelledError;
+  return value;
+}
+var SetupInputError, SetupCancelledError;
+var init_setup_input = __esm(() => {
+  init_dist3();
+  init_dist4();
+  SetupInputError = class SetupInputError extends Error {
+    code;
+    constructor(message, code = "invalid_input") {
+      super(message);
+      this.name = "SetupInputError";
+      this.code = code;
+    }
+  };
+  SetupCancelledError = class SetupCancelledError extends Error {
+    constructor() {
+      super("Integration setup was cancelled.");
+      this.name = "SetupCancelledError";
+    }
+  };
 });
 
 // src/commands/integrations/wait-for-connection.ts
 async function waitForIntegrationConnection({
   client,
   sessionId,
-  displayName,
-  cliName,
-  retryCommand
+  displayName
 }) {
   const spinner = createSpinner(`Waiting for ${displayName} authentication...`);
-  const result = await pollUntil(() => client.callTool("outlit_get_integration_setup_status", { sessionId }).then((r) => r), (r) => terminalConnectStatuses.has(r.status ?? ""), {
+  const result = await pollUntil((signal) => client.callTool("outlit_get_integration_setup_status", { sessionId }, { signal }).then((response) => response), (response) => response.status !== "pending", {
     intervalMs: 2000,
     timeoutMs: 300000,
     spinner,
-    spinnerMessage: `Waiting for ${displayName} authentication...`
+    spinnerMessage: `Waiting for ${displayName} authentication...`,
+    shouldRetry(error) {
+      if (!isOutlitToolsApiError(error))
+        return true;
+      if (error.envelope)
+        return error.envelope.retryable;
+      return error.status === 408 || error.status === 429 || error.status >= 500;
+    }
   });
-  if (!result || result.status === "expired") {
+  if (!result) {
     spinner.fail("Connection timed out");
-    console.log(`
-  The authentication session expired.`);
-    console.log(`  Run \`${retryCommand}\` to try again.`);
-    process.exit(1);
+    throw new IntegrationAuthTimeoutError;
   }
-  if (result.status === "failed") {
-    spinner.fail(`${displayName} connection failed`);
-    if (result.error)
-      console.log(`
-  ${result.error}`);
-    process.exit(1);
+  if (result.status === "expired" || result.status === "failed") {
+    spinner.fail(`${displayName} authentication ${result.status}`);
+    throw new IntegrationAuthError(result.status);
   }
   if (result.status !== "connected") {
-    spinner.fail(`${displayName} connection returned an invalid status`);
-    if (result.status)
-      console.log(`
-  Unexpected status: ${result.status}`);
-    process.exit(1);
+    spinner.fail("Connection timed out");
+    throw new IntegrationAuthTimeoutError;
   }
-  spinner.stop(`${displayName} connected successfully!`);
-  console.log(`    Sync will begin automatically.`);
-  console.log(`    Use \`outlit integrations status ${cliName}\` to check progress.`);
+  spinner.stop(`${displayName} authentication completed`);
 }
-var terminalConnectStatuses;
+var IntegrationAuthTimeoutError, IntegrationAuthError;
 var init_wait_for_connection = __esm(() => {
+  init_dist4();
   init_spinner();
-  terminalConnectStatuses = new Set(["connected", "failed", "expired"]);
+  IntegrationAuthTimeoutError = class IntegrationAuthTimeoutError extends Error {
+    constructor() {
+      super("Integration authentication timed out after 5 minutes.");
+      this.name = "IntegrationAuthTimeoutError";
+    }
+  };
+  IntegrationAuthError = class IntegrationAuthError extends Error {
+    status;
+    constructor(status) {
+      super(`Integration authentication ${status}.`);
+      this.name = "IntegrationAuthError";
+      this.status = status;
+    }
+  };
 });
 
 // src/commands/integrations/setup.ts
 var exports_setup = {};
 __export(exports_setup, {
+  validateHandoffUrl: () => validateHandoffUrl,
   default: () => setup_default2
 });
+async function runPreferredSetup(options) {
+  const { client, json, machineMode, acceptRecommended, suppliedConfig } = options;
+  const provider = options.input.provider;
+  let input = options.input;
+  let setupCalls = 0;
+  let continuationUsed = false;
+  let mappingUsed = false;
+  const transitions = new Set;
+  while (setupCalls < 3) {
+    let response;
+    try {
+      const raw = await client.callTool("outlit_setup_integration", input);
+      setupCalls += 1;
+      if (!matchesGeneratedJsonSchema(raw, setupOutputSchema)) {
+        return invalidSetupResponse(json);
+      }
+      response = raw;
+    } catch (error) {
+      return outputApiError(error, json, {
+        message: "Integration setup request failed.",
+        code: "api_error"
+      });
+    }
+    if (response.error) {
+      if (response.error.code !== "CREDENTIAL_REQUIRED") {
+        return outputError({ message: response.error.message, code: response.error.code }, json);
+      }
+      if (continuationUsed || transitions.has("credential"))
+        return stalled(json);
+      if (machineMode || suppliedConfig) {
+        return outputError({ message: response.error.message, code: response.error.code }, json);
+      }
+      transitions.add("credential");
+      continuationUsed = true;
+      try {
+        input = await collectProviderCredentials(provider);
+      } catch (error) {
+        if (error instanceof SetupCancelledError || error instanceof SetupInputError) {
+          return outputError({
+            message: error.message,
+            code: error instanceof SetupInputError ? error.code : "SETUP_CANCELLED"
+          }, json);
+        }
+        return outputError({ message: "Could not collect provider credentials.", code: "SETUP_CANCELLED" }, json);
+      }
+      continue;
+    }
+    if (!response.next) {
+      if (response.status === "ready")
+        return finishSetup(response, machineMode);
+      return outputError({
+        message: "Integration setup requires attention before it can continue.",
+        code: "SETUP_INCOMPLETE"
+      }, json);
+    }
+    if (response.next.kind === "browser_handoff") {
+      let handoffUrl;
+      try {
+        handoffUrl = validateHandoffUrl(response.next.url, client.baseUrl);
+      } catch {
+        return invalidSetupResponse(json);
+      }
+      if (machineMode)
+        return finishSetup(response, true);
+      const opened = openBrowser(handoffUrl);
+      if (!opened)
+        console.log(`Open this URL to continue: ${handoffUrl}`);
+      if (response.next.purpose !== "authentication" || response.next.sessionId === null) {
+        return finishSetup(response, false);
+      }
+      if (continuationUsed || transitions.has("authentication"))
+        return stalled(json);
+      transitions.add("authentication");
+      continuationUsed = true;
+      try {
+        await waitForIntegrationConnection({
+          client,
+          sessionId: response.next.sessionId,
+          displayName: response.name
+        });
+      } catch (error) {
+        if (error instanceof IntegrationAuthTimeoutError) {
+          return outputError({
+            message: "Integration authentication timed out after 5 minutes.",
+            code: "AUTH_TIMEOUT"
+          }, json);
+        }
+        if (error instanceof IntegrationAuthError) {
+          return outputError({ message: "Integration authentication failed.", code: "AUTH_FAILED" }, json);
+        }
+        return outputApiError(error, json, {
+          message: "Integration authentication failed.",
+          code: "AUTH_FAILED"
+        });
+      }
+      input = authenticationContinuationInput(input);
+      continue;
+    }
+    if (response.next.kind === "crm_mapping") {
+      printRecommendation(response.next.recommendation, machineMode);
+      if (mappingUsed || transitions.has("crm_mapping"))
+        return stalled(json);
+      let shouldApply = acceptRecommended;
+      if (!acceptRecommended && !machineMode) {
+        try {
+          shouldApply = await confirmCrmRecommendation();
+        } catch (error) {
+          if (error instanceof SetupCancelledError) {
+            return outputError({ message: error.message, code: "SETUP_CANCELLED" }, json);
+          }
+          return outputError({ message: "Could not confirm the CRM mapping.", code: "SETUP_CANCELLED" }, json);
+        }
+      }
+      if (!shouldApply)
+        return finishSetup(response, machineMode);
+      mappingUsed = true;
+      transitions.add("crm_mapping");
+      input = {
+        provider,
+        configuration: {
+          kind: "crm_mapping",
+          mappings: response.next.recommendation,
+          confirm: true
+        }
+      };
+      continue;
+    }
+    if (response.next.kind === "mixpanel_mapping") {
+      if (mappingUsed || transitions.has("mixpanel_mapping"))
+        return stalled(json);
+      printMixpanelPreview(response.next.preview, machineMode);
+      if (machineMode || suppliedConfig)
+        return finishSetup(response, machineMode);
+      let mapping;
+      try {
+        mapping = await collectMixpanelMapping(response.next.preview.candidateAccountKeys ?? []);
+      } catch (error) {
+        if (error instanceof SetupCancelledError) {
+          return outputError({ message: error.message, code: "SETUP_CANCELLED" }, json);
+        }
+        return outputError({ message: "Could not collect the Mixpanel mapping.", code: "SETUP_CANCELLED" }, json);
+      }
+      mappingUsed = true;
+      transitions.add("mixpanel_mapping");
+      input = {
+        provider,
+        configuration: { kind: "mixpanel_mapping", mapping, confirm: true }
+      };
+      continue;
+    }
+    return invalidSetupResponse(json);
+  }
+  return stalled(json);
+}
+async function runLegacySetup(client, capability, json, machineMode) {
+  if (!capability.browserHandoffAvailable || capability.setupMode === "human_controlled") {
+    const controlPlaneUrl = validateHandoffUrl("/integrations", client.baseUrl);
+    return outputResult({
+      status: "human_controlled",
+      provider: capability.provider,
+      controlPlaneUrl,
+      capabilities: capability
+    });
+  }
+  const spinner = machineMode ? null : createSpinner(`Starting ${capability.name} setup...`);
+  let setup;
+  try {
+    setup = await client.callTool("outlit_begin_integration_setup", {
+      provider: capability.provider
+    });
+  } catch (error) {
+    spinner?.fail(`Failed to start ${capability.name} setup`);
+    return outputApiError(error, json, {
+      message: "Failed to start setup flow.",
+      code: "api_error"
+    });
+  }
+  if (setup.state === "already_connected") {
+    spinner?.stop(`${capability.name} is already connected`);
+    return outputResult({ status: "already_connected", ...setup, capabilities: capability });
+  }
+  if (!setup.connectUrl) {
+    spinner?.fail(`Failed to start ${capability.name} setup`);
+    return invalidSetupResponse(json);
+  }
+  let connectUrl;
+  try {
+    connectUrl = validateHandoffUrl(setup.connectUrl, client.baseUrl);
+  } catch {
+    spinner?.fail(`Failed to start ${capability.name} setup`);
+    return invalidSetupResponse(json);
+  }
+  if (!machineMode) {
+    const opened = openBrowser(connectUrl);
+    spinner?.stop(opened ? `Browser opened for ${capability.name}` : "Could not open browser");
+    if (!opened)
+      console.log(`Open this URL to continue: ${connectUrl}`);
+    if (setup.sessionId) {
+      try {
+        await waitForIntegrationConnection({
+          client,
+          sessionId: setup.sessionId,
+          displayName: capability.name
+        });
+      } catch (error) {
+        if (error instanceof IntegrationAuthTimeoutError || error instanceof IntegrationAuthError && error.status === "expired") {
+          return outputError({
+            message: "Integration authentication timed out after 5 minutes.",
+            code: "AUTH_TIMEOUT"
+          }, json);
+        }
+        return outputError({ message: "Integration authentication failed.", code: "AUTH_FAILED" }, json);
+      }
+      return;
+    }
+  }
+  return outputResult({
+    status: "awaiting_auth",
+    ...setup,
+    connectUrl,
+    capabilities: capability
+  });
+}
+function getUnsupportedSetupArgument(rawArgs) {
+  let foundProvider = false;
+  for (let index = 0;index < rawArgs.length; index += 1) {
+    const argument = rawArgs[index];
+    if (argument === undefined)
+      continue;
+    if (argument === "--api-key") {
+      const value = rawArgs[index + 1];
+      if (!value || value.startsWith("-"))
+        return argument;
+      index += 1;
+      continue;
+    }
+    if (argument.startsWith("--api-key=")) {
+      if (!argument.slice("--api-key=".length))
+        return argument;
+      continue;
+    }
+    if (argument === "--json" || argument === "--no-json" || argument === "--config-stdin" || argument === "--accept-recommended") {
+      continue;
+    }
+    if (argument.startsWith("-"))
+      return argument;
+    if (!foundProvider) {
+      foundProvider = true;
+      continue;
+    }
+    return argument;
+  }
+  return null;
+}
 async function fetchProviderCapability(client, provider, json) {
   try {
     const result = await client.callTool("outlit_get_integration_capabilities", {
       provider
     });
     const capability = result.providers?.find((candidate) => candidate.provider === provider);
-    if (capability)
-      return capability;
+    if (capability) {
+      return { capability, preferredSetupVersion: result.preferredSetupVersion };
+    }
     return outputError({ message: `Unknown integration: "${provider}"`, code: "unknown_provider" }, json);
   } catch (error) {
-    return outputError({
-      message: errorMessage(error, "Failed to fetch integration capabilities"),
+    return outputApiError(error, json, {
+      message: "Failed to fetch integration capabilities.",
       code: "api_error"
-    }, json);
+    });
+  }
+}
+function validateHandoffUrl(value, configuredBaseUrl) {
+  const configured = new URL(configuredBaseUrl);
+  const url = new URL(value, configured);
+  if (url.origin !== configured.origin)
+    throw new Error("Untrusted integration handoff origin");
+  if (url.protocol !== "https:" && !isLoopbackHostname(url.hostname)) {
+    throw new Error("Integration handoff must use HTTPS");
+  }
+  if (url.username || url.password || url.hash) {
+    throw new Error("Integration handoff contains unsafe URL credentials or fragment");
+  }
+  for (const [key, queryValue] of url.searchParams) {
+    if (/password|secret|credential|token|api[-_]?key|code/i.test(key)) {
+      throw new Error("Integration handoff contains an unsafe query parameter");
+    }
+    if (/^(?:ok_|rk_|phx_|whsec_)/i.test(queryValue)) {
+      throw new Error("Integration handoff contains credential material");
+    }
+  }
+  return url.toString();
+}
+function authenticationContinuationInput(input) {
+  const continuation = { provider: input.provider };
+  if (input.connectionMode !== undefined)
+    continuation.connectionMode = input.connectionMode;
+  if (input.configuration !== undefined)
+    continuation.configuration = input.configuration;
+  return continuation;
+}
+function isLoopbackHostname(hostname) {
+  const normalized = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  return normalized === "localhost" || normalized === "::1" || /^127(?:\.\d{1,3}){3}$/.test(normalized);
+}
+function printRecommendation(recommendation, machineMode) {
+  if (!machineMode) {
+    console.log(`Recommended CRM mapping:
+${JSON.stringify(recommendation, null, 2)}`);
+  }
+}
+function printMixpanelPreview(preview, machineMode) {
+  if (!machineMode) {
+    console.log(`Mixpanel mapping preview:
+${JSON.stringify(preview, null, 2)}`);
+  }
+}
+function finishSetup(response, machineMode) {
+  if (machineMode) {
+    outputResult(response);
+    return;
   }
+  console.log(`${response.name}: ${response.status}`);
 }
-var setup_default2;
+function invalidSetupResponse(json) {
+  return outputError({
+    message: "Outlit returned an invalid integration setup response.",
+    code: "INVALID_SETUP_RESPONSE"
+  }, json);
+}
+function stalled(json) {
+  return outputError({ message: STALLED_MESSAGE, code: "SETUP_STALLED" }, json);
+}
+var setupOutputSchema, STALLED_MESSAGE = "Integration setup did not reach a terminal state.", setup_default2;
 var init_setup2 = __esm(() => {
+  init_dist4();
   init_dist();
   init_auth();
   init_output2();
@@ -14493,19 +17010,23 @@ var init_setup2 = __esm(() => {
   init_output();
   init_spinner();
   init_tty();
+  init_setup_input();
   init_wait_for_connection();
+  setupOutputSchema = publicToolContracts.outlit_setup_integration.outputSchema;
   setup_default2 = defineCommand2({
     meta: {
       name: "setup",
       description: [
-        "Start a safe browser handoff for an integration.",
+        "Set up or repair an integration through credentials, configuration, or a safe handoff.",
         "",
-        "Credential and provider-specific configuration is completed in the Outlit web app.",
-        "Providers without browser handoff support return the human control-plane URL.",
+        "Interactive setup prompts for provider secrets only after Core requests them.",
+        "Automation may pass one strict JSON document on stdin with --config-stdin.",
+        "Supported actor-owned setup uses integrations:connect_own; workspace or admin setup uses integrations:manage.",
         "",
         "Examples:",
         "  outlit integrations setup slack",
         "  outlit integrations setup hubspot --json",
+        "  outlit integrations setup fireflies --config-stdin --json",
         "",
         AGENT_JSON_HINT
       ].join(`
@@ -14514,58 +17035,70 @@ var init_setup2 = __esm(() => {
     args: {
       ...authArgs,
       ...outputArgs,
+      "config-stdin": {
+        type: "boolean",
+        description: "Read one strict provider configuration JSON document from stdin"
+      },
+      "accept-recommended": {
+        type: "boolean",
+        description: "Apply the exact CRM mapping recommendation shown by this command"
+      },
       provider: {
         type: "positional",
         description: "Integration provider to set up",
         required: true
       }
     },
-    async run({ args }) {
+    async run({ args, rawArgs }) {
       const json = !!args.json;
+      const machineMode = isJsonMode(json);
+      const unsupportedArgument = getUnsupportedSetupArgument(rawArgs ?? []);
+      if (unsupportedArgument) {
+        return outputError({
+          message: "Integration setup accepts provider configuration only through --config-stdin; provider secrets are never CLI flags.",
+          code: "invalid_input"
+        }, json);
+      }
       const provider = normalizeProviderInput(args.provider);
       const client = await getClientOrExit(args["api-key"], json);
-      const capability = await fetchProviderCapability(client, provider, json);
-      if (!capability.browserHandoffAvailable || capability.setupMode === "human_controlled") {
-        return outputResult({
-          status: "human_controlled",
-          provider: capability.provider,
-          controlPlaneUrl: `${client.baseUrl}/integrations`,
-          capabilities: capability
-        });
+      const { capability, preferredSetupVersion } = await fetchProviderCapability(client, provider, json);
+      if (preferredSetupVersion !== 1) {
+        if (args["config-stdin"] || args["accept-recommended"]) {
+          return outputError({
+            message: "This Outlit deployment does not support negotiated setup; --config-stdin and --accept-recommended are unavailable.",
+            code: "unsupported_core_version"
+          }, json);
+        }
+        return runLegacySetup(client, capability, json, machineMode);
       }
-      const spinner = createSpinner(`Starting ${capability.name} setup...`);
-      let setup;
-      try {
-        setup = await client.callTool("outlit_begin_integration_setup", {
-          provider: capability.provider
-        });
-      } catch (error) {
-        spinner.fail(`Failed to start ${capability.name} setup`);
-        return outputError({ message: errorMessage(error, "Failed to start setup flow"), code: "api_error" }, json);
-      }
-      if (setup.state === "already_connected") {
-        spinner.stop(`${capability.name} is already connected`);
-        return outputResult({ status: "already_connected", ...setup, capabilities: capability });
-      }
-      if (!json && setup.connectUrl) {
-        const opened = openBrowser(setup.connectUrl);
-        spinner.stop(opened ? `Browser opened for ${capability.name}` : "Could not open browser");
-        if (!opened)
-          console.log(`Open this URL to continue: ${setup.connectUrl}`);
-        if (setup.sessionId) {
-          await waitForIntegrationConnection({
-            client,
-            sessionId: setup.sessionId,
-            displayName: capability.name,
-            cliName: capability.provider,
-            retryCommand: `outlit integrations setup ${capability.provider}`
-          });
-          return;
+      let initialInput = { provider: capability.provider };
+      if (args["config-stdin"]) {
+        try {
+          initialInput = parseSetupConfig(await readSetupConfigText(), capability.provider);
+        } catch (error) {
+          if (error instanceof SetupInputError) {
+            return outputError({ message: error.message, code: error.code }, json);
+          }
+          return outputError({
+            message: "Could not read integration configuration from stdin.",
+            code: "invalid_input"
+          }, json);
         }
-      } else {
-        spinner.stop(`Started ${capability.name} setup`);
       }
-      return outputResult({ status: "awaiting_auth", ...setup, capabilities: capability });
+      if (args["accept-recommended"] && hasCrmConfiguration(initialInput)) {
+        return outputError({
+          message: "--accept-recommended conflicts with a supplied CRM configuration.",
+          code: "invalid_input"
+        }, json);
+      }
+      return runPreferredSetup({
+        client,
+        input: initialInput,
+        json,
+        machineMode,
+        acceptRecommended: !!args["accept-recommended"],
+        suppliedConfig: !!args["config-stdin"]
+      });
     }
   });
 });
@@ -14575,46 +17108,25 @@ var exports_status2 = {};
 __export(exports_status2, {
   default: () => status_default2
 });
-function hideBlankModelSyncs(data) {
-  if (typeof data !== "object" || data === null || Array.isArray(data)) {
-    return data;
-  }
-  const record = data;
-  if (!Array.isArray(record.syncs)) {
-    return data;
-  }
-  return {
-    ...record,
-    syncs: record.syncs.filter((sync) => {
-      if (typeof sync !== "object" || sync === null || Array.isArray(sync)) {
-        return false;
-      }
-      const model = sync.model;
-      return typeof model === "string" && model.trim().length > 0;
-    })
-  };
-}
 var status_default2;
 var init_status2 = __esm(() => {
   init_dist();
   init_auth();
   init_output2();
   init_api();
-  init_output();
   status_default2 = defineCommand2({
     meta: {
       name: "status",
       description: [
-        "Show sync status for connected integrations.",
+        "Show canonical integration readiness for agents and operators.",
         "",
-        "Without a provider name, shows a summary of all connected integrations.",
-        "With a provider name, shows detailed per-model sync status.",
-        "With --session, checks a browser-auth setup session returned by `integrations setup`.",
+        "Without a provider name, shows the status of every available integration.",
+        "With a provider name, returns its single canonical readiness status.",
+        "Status reports configuration readiness, not sync, backfill, or data availability.",
         "",
         "Examples:",
-        "  outlit integrations status              # summary of all",
-        "  outlit integrations status stripe       # detailed Stripe sync status",
-        "  outlit integrations status --session 550e8400-e29b-41d4-a716-446655440000 --json",
+        "  outlit integrations status",
+        "  outlit integrations status stripe --json",
         "",
         AGENT_JSON_HINT
       ].join(`
@@ -14625,49 +17137,22 @@ var init_status2 = __esm(() => {
       ...outputArgs,
       provider: {
         type: "positional",
-        description: "Provider name to show detailed status for (optional)",
+        description: "Provider name to inspect (optional)",
         required: false
-      },
-      session: {
-        type: "string",
-        description: "Browser-auth setup session ID returned by `outlit integrations setup <provider>`."
       }
     },
     async run({ args }) {
       const json = !!args.json;
       const client = await getClientOrExit(args["api-key"], json);
-      if (args.session && args.provider) {
-        return outputError({ message: "Use either a provider name or --session, not both.", code: "invalid_input" }, json);
-      }
-      if (args.session) {
-        return runTool(client, "outlit_get_integration_setup_status", { sessionId: args.session }, json, {
-          spinnerMessage: "Checking setup session..."
-        });
-      }
-      if (args.provider) {
-        return runTool(client, "outlit_get_integration_sync_status", { provider: normalizeProviderInput(args.provider) }, json, {
-          spinnerMessage: "Fetching sync status...",
-          transform: hideBlankModelSyncs,
-          table: {
-            columns: [
-              { header: "Model", key: "model" },
-              { header: "Status", key: "status" },
-              { header: "Records", key: "recordCount", format: formatNumber },
-              { header: "Last Synced", key: "lastSyncedAt", format: relativeDate }
-            ],
-            itemsKey: "syncs"
-          }
-        });
-      }
-      return runTool(client, "outlit_list_integrations", { connectedOnly: true }, json, {
+      const provider = args.provider ? normalizeProviderInput(args.provider) : undefined;
+      return runTool(client, "outlit_get_integration_status", provider ? { provider } : {}, json, {
         spinnerMessage: "Fetching integration status...",
         table: {
           itemsKey: "integrations",
           columns: [
-            { header: "Name", key: "name", format: (v) => truncate(v, 24) },
+            { header: "Name", key: "name", format: (value) => truncate(value, 24) },
             { header: "Category", key: "category", format: capitalize },
-            { header: "Sync Status", key: "syncStatus" },
-            { header: "Last Synced", key: "lastDataReceivedAt", format: relativeDate }
+            { header: "Status", key: "status" }
           ]
         }
       });
@@ -14687,26 +17172,19 @@ var init_integrations = __esm(() => {
     meta: {
       name: "integrations",
       description: [
-        "Manage platform integrations (communication, analytics, billing, etc.).",
+        "Set up actor-owned integrations and inspect canonical readiness.",
         "",
-        "Inspect integrations, start safe browser handoffs, and check sync status.",
+        "Supported actor-owned setup uses integrations:connect_own; workspace or admin setup uses integrations:manage.",
         "",
         "Commands:",
-        "  list                List available integrations and connection status",
-        "  capabilities [provider]",
-        "                      Show safe setup mode and browser-handoff availability",
-        "  setup <provider>    Start a browser handoff when supported",
-        "  status --session <id>",
-        "                      Poll browser-auth setup status returned by setup JSON output",
-        "  status [provider]   Show sync status for connected integrations",
-        "",
-        "Credential and provider-specific configuration remains in the Outlit web app."
+        "  setup <provider>    Run bounded provider setup when authorized",
+        "  status [provider]   Show canonical integration readiness",
+        "",
+        "Core determines whether the requested setup is actor-owned or workspace/admin scoped."
       ].join(`
 `)
     },
     subCommands: {
-      list: () => Promise.resolve().then(() => (init_list7(), exports_list7)).then((m) => m.default),
-      capabilities: () => Promise.resolve().then(() => (init_capabilities(), exports_capabilities)).then((m) => m.default),
       setup: () => Promise.resolve().then(() => (init_setup2(), exports_setup)).then((m) => m.default),
       status: () => Promise.resolve().then(() => (init_status2(), exports_status2)).then((m) => m.default)
     }
@@ -14935,6 +17413,31 @@ var init_completions = __esm(() => {
             { name: "--start-date", desc: "Start date (ISO 8601)" },
             { name: "--end-date", desc: "End date (ISO 8601)" }
           ]
+        },
+        {
+          name: "owner",
+          desc: "Manage the primary customer owner",
+          subs: [
+            {
+              name: "set",
+              desc: "Assign the primary customer owner",
+              flags: [...COMMON, { name: "--target-user-id", desc: "Required workspace-user ID" }]
+            }
+          ]
+        },
+        {
+          name: "grant",
+          desc: "Grant or change Viewer or Editor customer access",
+          flags: [
+            ...COMMON,
+            { name: "--target-user-id", desc: "Required workspace-user ID" },
+            { name: "--role", desc: "Required access role (VIEWER, EDITOR)" }
+          ]
+        },
+        {
+          name: "revoke",
+          desc: "Revoke explicit customer access",
+          flags: [...COMMON, { name: "--target-user-id", desc: "Required workspace-user ID" }]
         }
       ]
     },
@@ -14993,13 +17496,13 @@ var init_completions = __esm(() => {
       subs: [
         {
           name: "list",
-          desc: "List and filter internal workspace users",
+          desc: "List eligible active workspace members",
           flags: [
             ...PAGINATED,
             { name: "--search", desc: "Search name, email, title, role, or territory" },
             { name: "--role", desc: "Filter by role metadata" },
             { name: "--manager-email", desc: "Filter by manager email" },
-            { name: "--has-owned-customers", desc: "Only users who own customers" },
+            { name: "--has-owned-customers", desc: "Only members who own customers" },
             { name: "--order-by", desc: "Sort field" },
             { name: "--order-direction", desc: "Sort direction (asc, desc)" }
           ]
@@ -15089,17 +17592,19 @@ var init_completions = __esm(() => {
       name: "integrations",
       desc: "Manage platform integrations",
       subs: [
-        { name: "list", desc: "List integrations and status", flags: [...COMMON] },
-        { name: "capabilities", desc: "Show setup capabilities", flags: [JSON_F] },
         {
           name: "setup",
-          desc: "Start a safe browser setup handoff",
-          flags: [...COMMON]
+          desc: "Set up or repair an integration",
+          flags: [
+            ...COMMON,
+            { name: "--config-stdin", desc: "Read provider configuration JSON from stdin" },
+            { name: "--accept-recommended", desc: "Apply the exact CRM recommendation" }
+          ]
         },
         {
           name: "status",
-          desc: "Show sync or setup-session status",
-          flags: [...COMMON, { name: "--session", desc: "Browser-auth setup session ID" }]
+          desc: "Show configuration readiness",
+          flags: [...COMMON]
         }
       ]
     },
@@ -15150,6 +17655,39 @@ var init_completions = __esm(() => {
         }
       ]
     },
+    {
+      name: "metrics",
+      desc: "Configure Behavior Metrics",
+      subs: [
+        {
+          name: "sources",
+          desc: "List product-event sources eligible for Behavior Metrics",
+          flags: [...COMMON]
+        },
+        {
+          name: "events",
+          desc: "List attributed event candidates for a Behavior Metric source",
+          flags: [
+            ...COMMON,
+            { name: "--source", desc: "Behavior Metric source key" },
+            { name: "--weeks", desc: "History window in weeks (1-53, default: 12)" },
+            { name: "--limit", desc: "Maximum event candidates (1-100, default: 100)" }
+          ]
+        },
+        {
+          name: "create",
+          desc: "Create an event-based Behavior Metric",
+          flags: [
+            ...COMMON,
+            { name: "--source", desc: "Behavior Metric source key" },
+            { name: "--event", desc: "Exact tracked event name" },
+            { name: "--key", desc: "Stable lower_snake_case metric key" },
+            { name: "--label", desc: "Human-readable metric label" },
+            { name: "--property-filters", desc: "Optional JSON event property filters" }
+          ]
+        }
+      ]
+    },
     {
       name: "onboard",
       desc: "Prepare a coding agent for Outlit",
@@ -15966,6 +18504,9 @@ Usage examples:
   outlit activation get --json
   outlit activation preview --event integration_connected --json
   outlit destinations disable 10000000-0000-4000-8000-000000000003 --json
+  outlit metrics sources --json
+  outlit metrics events --source metric_source_v1_0123456789abcdef0123456789abcdef --json
+  outlit metrics create --source metric_source_v1_0123456789abcdef0123456789abcdef --event report_exported --key reports_exported --label 'Reports exported' --json
   outlit doctor --json
 
 For AI agents: commands auto-output JSON when stdout is piped. No --json flag needed.`
@@ -15985,6 +18526,7 @@ For AI agents: commands auto-output JSON when stdout is piped. No --json flag ne
       sql: () => Promise.resolve().then(() => (init_sql(), exports_sql)).then((m) => m.default),
       schema: () => Promise.resolve().then(() => (init_schema(), exports_schema)).then((m) => m.default),
       destinations: () => Promise.resolve().then(() => (init_destinations(), exports_destinations)).then((m) => m.default),
+      metrics: () => Promise.resolve().then(() => (init_metrics(), exports_metrics)).then((module) => module.default),
       settings: () => Promise.resolve().then(() => (init_settings(), exports_settings)).then((m) => m.default),
       integrations: () => Promise.resolve().then(() => (init_integrations(), exports_integrations)).then((m) => m.default),
       completions: () => Promise.resolve().then(() => (init_completions(), exports_completions)).then((m) => m.default),