sf-intelligence 0.1.22 → 0.1.24

package/dist/index.js

@@ -21564,13 +21564,13 @@ var init_auth = __esm({
         stdout = result.stdout;
       } catch (cause) {
         const codeBag = cause;
-        if (codeBag.code === "ENOENT") {
+        const stderrOrMsg = codeBag.stderr ?? codeBag.message ?? String(cause);
+        if (codeBag.code === "ENOENT" || stderrOrMsg.includes("is not recognized as an internal or external command")) {
           return err({
             kind: "sf-cli-missing",
             message: "The `sf` CLI is not installed or not on PATH. Install it from https://developer.salesforce.com/tools/sfdxcli and run `sf org login web --target-org <alias>` to authenticate."
           });
         }
-        const stderrOrMsg = codeBag.stderr ?? codeBag.message ?? String(cause);
         if (stderrOrMsg.includes("No authentication for org") || stderrOrMsg.includes("NoOrgFound") || stderrOrMsg.includes("Unknown org")) {
           return err({
             kind: "org-not-found",
@@ -22484,9 +22484,13 @@ var init_picklist_literal_check = __esm({
 // ../mcp/dist/src/tools/live-plane.js
 var live_plane_exports = {};
 __export(live_plane_exports, {
+  GROUP_MEMBERS_DISCLOSURE: () => GROUP_MEMBERS_DISCLOSURE,
   LICENSE_USAGE_DISCLOSURE: () => LICENSE_USAGE_DISCLOSURE,
   LIVE_PLANE_DISCLOSURE: () => LIVE_PLANE_DISCLOSURE,
+  PERMSET_HOLDERS_DISCLOSURE: () => PERMSET_HOLDERS_DISCLOSURE,
   STALE_CHECK_TYPES: () => STALE_CHECK_TYPES,
+  USER_PERMSETS_DISCLOSURE: () => USER_PERMSETS_DISCLOSURE,
+  ZOMBIE_ACCOUNTS_DISCLOSURE: () => ZOMBIE_ACCOUNTS_DISCLOSURE,
   apiPath: () => apiPath,
   assertSoqlIdentifier: () => assertSoqlIdentifier,
   checkVaultStaleness: () => checkVaultStaleness,
@@ -22513,6 +22517,8 @@ __export(live_plane_exports, {
   liveFolderAccessInputSchema: () => liveFolderAccessInputSchema,
   liveGroupCountHandler: () => liveGroupCountHandler,
   liveGroupCountInputSchema: () => liveGroupCountInputSchema,
+  liveGroupMembersHandler: () => liveGroupMembersHandler,
+  liveGroupMembersInputSchema: () => liveGroupMembersInputSchema,
   liveInactiveUsersHandler: () => liveInactiveUsersHandler,
   liveInactiveUsersInputSchema: () => liveInactiveUsersInputSchema,
   liveLicenseUsageHandler: () => liveLicenseUsageHandler,
@@ -22523,6 +22529,8 @@ __export(live_plane_exports, {
   liveOrgLimitsInputSchema: () => liveOrgLimitsInputSchema,
   liveOwnerBreakdownHandler: () => liveOwnerBreakdownHandler,
   liveOwnerBreakdownInputSchema: () => liveOwnerBreakdownInputSchema,
+  livePermsetHoldersHandler: () => livePermsetHoldersHandler,
+  livePermsetHoldersInputSchema: () => livePermsetHoldersInputSchema,
   liveRecentActivityHandler: () => liveRecentActivityHandler,
   liveRecentActivityInputSchema: () => liveRecentActivityInputSchema,
   liveReportUsageHandler: () => liveReportUsageHandler,
@@ -22539,13 +22547,17 @@ __export(live_plane_exports, {
   liveStaleRecordsInputSchema: () => liveStaleRecordsInputSchema,
   liveStorageByObjectHandler: () => liveStorageByObjectHandler,
   liveStorageByObjectInputSchema: () => liveStorageByObjectInputSchema,
+  liveUserPermsetsHandler: () => liveUserPermsetsHandler,
+  liveUserPermsetsInputSchema: () => liveUserPermsetsInputSchema,
+  liveZombieAccountsHandler: () => liveZombieAccountsHandler,
+  liveZombieAccountsInputSchema: () => liveZombieAccountsInputSchema,
   redactSecrets: () => redactSecrets,
   resolveLiveAccess: () => resolveLiveAccess,
   restGet: () => restGet,
   runSfJson: () => runSfJson
 });
 import { z as z2 } from "zod";
-var MAX_SAMPLE_ROWS, SAMPLE_BYTE_BUDGET, LIVE_TABLE_ROW_CAP, liveEnabledSchema, isLivePlaneEnabled, liveTrust, resolveOrg, resolveLiveAccess, liveConsentRequiredError, gateLive, liveDescribeInputSchema, liveDescribeHandler, liveCountInputSchema, OBJECT_API_NAME_RE, resolveCountSoql, assertCountSoql, fromObjectOf, NO_VALIDATION, collectPicklistMismatches, scanSoqlForPicklistMismatchesSync, liveCountHandler, liveStaleCheckInputSchema, STALE_CHECK_TYPES, ISO_TIMESTAMP_RE, LIVE_STALE_BOUNDARIES, checkVaultStaleness, liveStaleCheckHandler, liveSampleInputSchema, capSampleSoql, liveSampleHandler, liveFieldPopulationInputSchema, liveFieldPopulationHandler, liveOrgLimitsInputSchema, liveOrgLimitsHandler, MAX_INACTIVE_USER_ROWS, DEFAULT_INACTIVE_USER_ROWS, INACTIVE_USERS_BYTE_BUDGET, DEFAULT_INACTIVE_DAYS, MS_PER_DAY, liveInactiveUsersInputSchema, soqlDateTime, fitInactiveUsers, liveInactiveUsersHandler, DEFAULT_LICENSE_INACTIVE_DAYS, MAX_RECLAIM_ROWS, LICENSE_USAGE_DISCLOSURE, liveLicenseUsageInputSchema, toUtilization, renderLicenseUsageMarkdown, liveLicenseUsageHandler, liveConsentInputSchema, consentTrust, liveConsentHandler, liveQuery, MAX_DETAIL_ROWS, daysAgoSoql, daysSince, livePlaneVaultState, UNAVAILABLE_ERROR, isBudgetExhaustedReason, BUDGET_SIGNAL, assertSoqlIdentifier, soqlLiteral, MAX_GROUP_BUCKETS, DEFAULT_STALE_DAYS, DEFAULT_RECENT_DAYS, liveGroupCountInputSchema, liveGroupCountHandler, liveStaleRecordsInputSchema, liveStaleRecordsHandler, liveRecentActivityInputSchema, liveRecentActivityHandler, buildEqualityWhere, aggregateCountFromRow, liveAggregateInputSchema, liveAggregateHandler, MAX_DUPLICATE_GROUPS, liveDuplicateCheckInputSchema, liveDuplicateCheckHandler, MAX_OWNER_BUCKETS, liveOwnerBreakdownInputSchema, liveOwnerBreakdownHandler, DEFAULT_REPORT_STALE_DAYS, liveReportUsageInputSchema, liveReportUsageHandler, liveFolderAccessInputSchema, liveFolderAccessHandler, DEFAULT_TEMPLATE_STALE_DAYS, CLASSIC_TEMPLATE_TYPES, liveEmailTemplateUsageInputSchema, liveEmailTemplateUsageHandler, DEFAULT_HEALTH_DAYS, LIMIT_RISK_THRESHOLD, liveOrgHealthInputSchema, liveOrgHealthHandler, liveStorageByObjectInputSchema, liveStorageByObjectHandler, DEFAULT_SKEW_THRESHOLD, liveDataSkewInputSchema, liveDataSkewHandler, DEFAULT_AUDIT_DAYS, liveSetupAuditTrailInputSchema, liveSetupAuditTrailHandler, liveSecurityExposureInputSchema, liveSecurityExposureHandler;
+var MAX_SAMPLE_ROWS, SAMPLE_BYTE_BUDGET, LIVE_TABLE_ROW_CAP, liveEnabledSchema, isLivePlaneEnabled, liveTrust, resolveOrg, resolveLiveAccess, liveConsentRequiredError, gateLive, liveDescribeInputSchema, liveDescribeHandler, liveCountInputSchema, OBJECT_API_NAME_RE, resolveCountSoql, assertCountSoql, fromObjectOf, NO_VALIDATION, collectPicklistMismatches, scanSoqlForPicklistMismatchesSync, liveCountHandler, liveStaleCheckInputSchema, STALE_CHECK_TYPES, ISO_TIMESTAMP_RE, LIVE_STALE_BOUNDARIES, checkVaultStaleness, liveStaleCheckHandler, liveSampleInputSchema, capSampleSoql, liveSampleHandler, liveFieldPopulationInputSchema, liveFieldPopulationHandler, liveOrgLimitsInputSchema, liveOrgLimitsHandler, MAX_INACTIVE_USER_ROWS, DEFAULT_INACTIVE_USER_ROWS, INACTIVE_USERS_BYTE_BUDGET, DEFAULT_INACTIVE_DAYS, MS_PER_DAY, liveInactiveUsersInputSchema, soqlDateTime, fitInactiveUsers, liveInactiveUsersHandler, DEFAULT_LICENSE_INACTIVE_DAYS, MAX_RECLAIM_ROWS, LICENSE_USAGE_DISCLOSURE, liveLicenseUsageInputSchema, toUtilization, renderLicenseUsageMarkdown, liveLicenseUsageHandler, liveConsentInputSchema, consentTrust, liveConsentHandler, liveQuery, MAX_DETAIL_ROWS, daysAgoSoql, daysSince, livePlaneVaultState, UNAVAILABLE_ERROR, isBudgetExhaustedReason, BUDGET_SIGNAL, assertSoqlIdentifier, soqlLiteral, MAX_GROUP_BUCKETS, DEFAULT_STALE_DAYS, DEFAULT_RECENT_DAYS, liveGroupCountInputSchema, liveGroupCountHandler, liveStaleRecordsInputSchema, liveStaleRecordsHandler, liveRecentActivityInputSchema, liveRecentActivityHandler, buildEqualityWhere, aggregateCountFromRow, liveAggregateInputSchema, liveAggregateHandler, MAX_DUPLICATE_GROUPS, liveDuplicateCheckInputSchema, liveDuplicateCheckHandler, MAX_OWNER_BUCKETS, liveOwnerBreakdownInputSchema, liveOwnerBreakdownHandler, DEFAULT_REPORT_STALE_DAYS, liveReportUsageInputSchema, liveReportUsageHandler, liveFolderAccessInputSchema, liveFolderAccessHandler, DEFAULT_TEMPLATE_STALE_DAYS, CLASSIC_TEMPLATE_TYPES, liveEmailTemplateUsageInputSchema, liveEmailTemplateUsageHandler, DEFAULT_HEALTH_DAYS, LIMIT_RISK_THRESHOLD, liveOrgHealthInputSchema, liveOrgHealthHandler, liveStorageByObjectInputSchema, liveStorageByObjectHandler, DEFAULT_SKEW_THRESHOLD, liveDataSkewInputSchema, liveDataSkewHandler, DEFAULT_AUDIT_DAYS, liveSetupAuditTrailInputSchema, liveSetupAuditTrailHandler, liveSecurityExposureInputSchema, liveSecurityExposureHandler, MAX_HOLDER_ROWS, DEFAULT_HOLDER_ROWS, HOLDERS_BYTE_BUDGET, MAX_HOLDER_BUCKETS, PERMSET_HOLDERS_DISCLOSURE, livePermsetHoldersInputSchema, holderNotFoundError, holderAmbiguousError, resolveHolderTarget, toPermsetHolder, renderPermsetHoldersMarkdown, aggregateNumber, livePermsetHoldersHandler, splitHolders, fitPermsetHolders, MAX_ZOMBIE_ROWS, DEFAULT_ZOMBIE_ROWS, ZOMBIE_BYTE_BUDGET, ZOMBIE_CLIENT_DIFF_CAP, ZOMBIE_ACCOUNTS_DISCLOSURE, liveZombieAccountsInputSchema, toZombieUser, renderZombieAccountsMarkdown, fitZombieUsers, liveZombieAccountsHandler, MAX_MEMBER_ROWS, DEFAULT_MEMBER_ROWS, MEMBERS_BYTE_BUDGET, MEMBER_ID_CHUNK, GROUP_MEMBERS_DISCLOSURE, liveGroupMembersInputSchema, idChunks, resolveMemberUsers, renderGroupMembersMarkdown, fitGroupMembers, liveGroupMembersHandler, MAX_USER_PERMSET_ROWS, DEFAULT_USER_PERMSET_ROWS, USER_PERMSETS_BYTE_BUDGET, USER_PERMSETS_DISCLOSURE, liveUserPermsetsInputSchema, renderUserPermsetsMarkdown, fitUserPermsets, liveUserPermsetsHandler;
 var init_live_plane = __esm({
   "../mcp/dist/src/tools/live-plane.js"() {
     "use strict";
@@ -24184,6 +24196,855 @@ ${renderTrustFooter(trust)}`;
         vaultState: livePlaneVaultState(ctx)
       });
     };
+    MAX_HOLDER_ROWS = 500;
+    DEFAULT_HOLDER_ROWS = 100;
+    HOLDERS_BYTE_BUDGET = 36e3;
+    MAX_HOLDER_BUCKETS = 50;
+    PERMSET_HOLDERS_DISCLOSURE = "Read-only; point-in-time as of queriedAt \u2014 never cached beyond the live-session TTL; roster is CURRENT org state, unlike vault answers.";
+    livePermsetHoldersInputSchema = liveEnabledSchema.extend({
+      /** PermissionSet.Name / PSG DeveloperName / Profile.Name (labels accepted). */
+      name: z2.string().min(1),
+      /** What `name` names. Default 'auto': probe PermissionSet → PermissionSetGroup
+       *  → Profile by exact name/label; no-match or ambiguity is an honest error,
+       *  never a guess. */
+      kind: z2.enum(["permissionSet", "permissionSetGroup", "profile", "auto"]).optional(),
+      /** Include inactive assignees (default false — active users only). */
+      includeInactiveAssignees: z2.boolean().optional(),
+      /** For kind 'permissionSet': also count holders who receive the set through a
+       *  PermissionSetGroup containing it (default TRUE — see the PSG trap above). */
+      includeViaGroups: z2.boolean().optional(),
+      /** Aggregation buckets for the headline (default 'profile'). */
+      groupBy: z2.enum(["none", "profile"]).optional(),
+      /** Max detail rows (default 100, hard cap 500); a ~36 KB byte budget may trim
+       *  the page further. `totalAssignees` is always the TRUE deduped count. */
+      limit: z2.number().int().min(1).max(MAX_HOLDER_ROWS).optional(),
+      /** Keyset paging: return rows with Id > afterId (use `nextAfterId`). */
+      afterId: z2.string().optional(),
+      orgAlias: z2.string().min(1).optional()
+    });
+    holderNotFoundError = (name, probed) => ({
+      kind: "component-not-found",
+      message: `No exact match for '${name}' \u2014 probed ${probed.join(", ")} by exact name/label in the live org. Check the API name (sfi.resolve can fix typos against the vault), or pass \`kind\` explicitly.`
+    });
+    holderAmbiguousError = (name, kind, count) => ({
+      kind: "invalid-query",
+      message: `'${name}' matches ${count}+ ${kind} records in the live org \u2014 refusing to guess. Use the exact API name (Name/DeveloperName), not a label shared by several.`
+    });
+    resolveHolderTarget = async (org, name, kind, exec) => {
+      const lit = soqlLiteral(name);
+      const probes = [
+        {
+          kind: "permissionSet",
+          // IsOwnedByProfile = false: every Profile owns a system permission set
+          // with a matching name — matching one here would silently answer the
+          // PROFILE question under the permissionSet kind.
+          soql: `SELECT Id, Name FROM PermissionSet WHERE (Name = ${lit} OR Label = ${lit}) AND IsOwnedByProfile = false LIMIT 2`,
+          nameField: "Name"
+        },
+        {
+          kind: "permissionSetGroup",
+          soql: `SELECT Id, DeveloperName FROM PermissionSetGroup WHERE (DeveloperName = ${lit} OR MasterLabel = ${lit}) LIMIT 2`,
+          nameField: "DeveloperName"
+        },
+        {
+          kind: "profile",
+          soql: `SELECT Id, Name FROM Profile WHERE Name = ${lit} LIMIT 2`,
+          nameField: "Name"
+        }
+      ];
+      const wanted = kind === void 0 || kind === "auto" ? probes : probes.filter((p2) => p2.kind === kind);
+      const probedKinds = [];
+      for (const probe of wanted) {
+        probedKinds.push(probe.kind);
+        const q2 = await liveQuery(org, probe.soql, exec);
+        if (!q2.available) {
+          return err({
+            kind: "invalid-query",
+            message: `Could not probe ${probe.kind} for '${name}': ${redactSecrets(q2.reason ?? "query failed").slice(0, 160)}`
+          });
+        }
+        if (q2.records.length > 1)
+          return err(holderAmbiguousError(name, probe.kind, q2.records.length));
+        if (q2.records.length === 1) {
+          const row = q2.records[0];
+          return ok({
+            kind: probe.kind,
+            id: String(row.Id ?? ""),
+            name: String(row[probe.nameField] ?? name)
+          });
+        }
+      }
+      return err(holderNotFoundError(name, probedKinds));
+    };
+    toPermsetHolder = (r2) => ({
+      assignmentId: String(r2.Id ?? ""),
+      userId: String(r2.AssigneeId ?? ""),
+      name: String(r2.Assignee?.Name ?? ""),
+      username: String(r2.Assignee?.Username ?? ""),
+      isActive: r2.Assignee?.IsActive === true,
+      profileName: r2.Assignee?.Profile?.Name ?? null,
+      expirationDate: r2.ExpirationDate ?? null,
+      viaGroup: r2.PermissionSetGroupId ? r2.PermissionSetGroup?.DeveloperName ?? r2.PermissionSetGroupId : null
+    });
+    renderPermsetHoldersMarkdown = (data) => {
+      const kindLabel = {
+        permissionSet: "permission set",
+        permissionSetGroup: "permission set group",
+        profile: "profile"
+      };
+      const direct = data.directHolders.length;
+      const viaGroups = (data.viaGroupHolders ?? []).reduce((n2, g2) => n2 + g2.holders.length, 0);
+      const lines = [
+        `### Holders of ${kindLabel[data.target.kind]} \`${data.target.name}\``,
+        "",
+        `**${data.totalAssignees.toLocaleString("en-US")}** ${data.target.kind === "profile" ? "users hold this profile" : "distinct users hold this"}` + (data.target.kind === "permissionSet" ? ` (${direct} direct row(s), ${viaGroups} via-group row(s) on this page)` : "") + (data.expiredExcluded > 0 ? `; ${data.expiredExcluded} expired assignment(s) excluded` : "") + "."
+      ];
+      if (data.buckets !== void 0 && data.buckets.length > 0) {
+        lines.push("", "**By profile**", "", mdTable(["Profile", "Holders"], data.buckets.map((b2) => [b2.profileName ?? b2.profileId ?? "(none)", b2.holders])));
+      }
+      const holderRows = (holders) => mdTable(["User", "Username", "Profile", "Active", "Expires"], holders.map((h2) => [
+        h2.name,
+        h2.username,
+        h2.profileName ?? "\u2014",
+        h2.isActive ? "yes" : "no",
+        h2.expirationDate ?? "\u2014"
+      ]));
+      if (data.directHolders.length > 0) {
+        lines.push("", data.target.kind === "permissionSet" ? "**Direct holders**" : "**Holders**", "", holderRows(data.directHolders));
+      }
+      for (const g2 of data.viaGroupHolders ?? []) {
+        if (g2.holders.length > 0) {
+          lines.push("", `**Via group \`${g2.groupName}\`**`, "", holderRows(g2.holders));
+        }
+      }
+      if (data.capped) {
+        lines.push("", `Showing ${data.returned} of ${data.totalAssignees} holder(s)` + (data.nextAfterId !== void 0 ? ` \u2014 pass \`afterId: "${data.nextAfterId}"\` for the next page.` : "."));
+      }
+      lines.push("", PERMSET_HOLDERS_DISCLOSURE, "", renderTrustFooter(data.trust));
+      return lines.join("\n");
+    };
+    aggregateNumber = (records, alias) => {
+      const row = records[0];
+      if (row === void 0)
+        return 0;
+      return Number(row[alias] ?? row["expr0"] ?? 0);
+    };
+    livePermsetHoldersHandler = async (ctx, input2, exec = nodeExecFile2) => {
+      const gate = await gateLive(ctx, input2);
+      if (!gate.ok)
+        return gate;
+      const org = gate.value;
+      const queriedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const limit = input2.limit ?? DEFAULT_HOLDER_ROWS;
+      const groupBy = input2.groupBy ?? "profile";
+      const includeViaGroups = input2.includeViaGroups ?? true;
+      const nowLiteral = soqlDateTime(/* @__PURE__ */ new Date());
+      const resolved = await resolveHolderTarget(org, input2.name, input2.kind, exec);
+      if (!resolved.ok)
+        return resolved;
+      const target = resolved.value;
+      if (input2.afterId !== void 0 && !/^[a-zA-Z0-9]{15,18}$/.test(input2.afterId)) {
+        return err({
+          kind: "invalid-query",
+          message: "afterId must be a Salesforce record Id (the `nextAfterId` from the previous page).",
+          path: "afterId"
+        });
+      }
+      const afterClause = input2.afterId !== void 0 ? ` AND Id > '${input2.afterId}'` : "";
+      if (target.kind === "profile") {
+        const activeClause2 = input2.includeInactiveAssignees ? "" : " AND IsActive = true";
+        const where2 = `ProfileId = '${target.id}'${activeClause2}`;
+        const totalQ2 = await liveQuery(org, `SELECT COUNT() FROM User WHERE ${where2}`, exec);
+        if (!totalQ2.available)
+          return err(UNAVAILABLE_ERROR("User", org, totalQ2.reason));
+        const totalAssignees2 = totalQ2.total;
+        let activeAssignees2 = totalAssignees2;
+        if (input2.includeInactiveAssignees) {
+          const activeQ = await liveQuery(org, `SELECT COUNT() FROM User WHERE ProfileId = '${target.id}' AND IsActive = true`, exec);
+          if (!activeQ.available)
+            return err(UNAVAILABLE_ERROR("User", org, activeQ.reason));
+          activeAssignees2 = activeQ.total;
+        }
+        const detailQ2 = await liveQuery(org, `SELECT Id, Name, Username, IsActive, Profile.Name FROM User WHERE ${where2}${afterClause} ORDER BY Id LIMIT ${limit}`, exec);
+        if (!detailQ2.available)
+          return err(UNAVAILABLE_ERROR("User", org, detailQ2.reason));
+        const holders = detailQ2.records.map((r2) => ({
+          assignmentId: null,
+          userId: String(r2.Id ?? ""),
+          name: String(r2.Name ?? ""),
+          username: String(r2.Username ?? ""),
+          isActive: r2.IsActive === true,
+          profileName: r2.Profile?.Name ?? null,
+          expirationDate: null,
+          viaGroup: null
+        }));
+        return ok({
+          data: fitPermsetHolders({
+            target,
+            totalAssignees: totalAssignees2,
+            activeAssignees: activeAssignees2,
+            expiredExcluded: 0,
+            trust: liveTrust(queriedAt)
+          }, holders, [], void 0),
+          vaultState: livePlaneVaultState(ctx)
+        });
+      }
+      let viaGroups = [];
+      if (target.kind === "permissionSet" && includeViaGroups) {
+        const psgcQ = await liveQuery(org, `SELECT PermissionSetGroupId, PermissionSetGroup.DeveloperName FROM PermissionSetGroupComponent WHERE PermissionSetId = '${target.id}'`, exec);
+        if (!psgcQ.available) {
+          return err(UNAVAILABLE_ERROR("PermissionSetGroupComponent", org, psgcQ.reason));
+        }
+        viaGroups = psgcQ.records.map((r2) => {
+          const row = r2;
+          return {
+            id: String(row.PermissionSetGroupId ?? ""),
+            name: String(row.PermissionSetGroup?.DeveloperName ?? row.PermissionSetGroupId ?? "")
+          };
+        });
+      }
+      const scope = target.kind === "permissionSetGroup" ? `PermissionSetGroupId = '${target.id}'` : viaGroups.length > 0 ? `((PermissionSetId = '${target.id}' AND PermissionSetGroupId = null) OR PermissionSetGroupId IN (${viaGroups.map((g2) => `'${g2.id}'`).join(", ")}))` : `(PermissionSetId = '${target.id}' AND PermissionSetGroupId = null)`;
+      const activeClause = input2.includeInactiveAssignees ? "" : " AND Assignee.IsActive = true";
+      const notExpiredClause = ` AND (ExpirationDate = null OR ExpirationDate >= ${nowLiteral})`;
+      const where = `${scope}${activeClause}${notExpiredClause}`;
+      const totalQ = await liveQuery(org, `SELECT COUNT_DISTINCT(AssigneeId) total FROM PermissionSetAssignment WHERE ${where}`, exec);
+      if (!totalQ.available)
+        return err(UNAVAILABLE_ERROR("PermissionSetAssignment", org, totalQ.reason));
+      const totalAssignees = aggregateNumber(totalQ.records, "total");
+      let activeAssignees = totalAssignees;
+      if (input2.includeInactiveAssignees) {
+        const activeQ = await liveQuery(org, `SELECT COUNT_DISTINCT(AssigneeId) total FROM PermissionSetAssignment WHERE ${scope} AND Assignee.IsActive = true${notExpiredClause}`, exec);
+        if (!activeQ.available)
+          return err(UNAVAILABLE_ERROR("PermissionSetAssignment", org, activeQ.reason));
+        activeAssignees = aggregateNumber(activeQ.records, "total");
+      }
+      const expiredQ = await liveQuery(org, `SELECT COUNT() FROM PermissionSetAssignment WHERE ${scope}${activeClause} AND ExpirationDate < ${nowLiteral}`, exec);
+      const expiredExcluded = expiredQ.available ? expiredQ.total : 0;
+      let buckets;
+      if (groupBy === "profile") {
+        const bucketQ = await liveQuery(org, `SELECT Assignee.ProfileId pid, MAX(Assignee.Profile.Name) pname, COUNT(Id) holders FROM PermissionSetAssignment WHERE ${where} GROUP BY Assignee.ProfileId ORDER BY COUNT(Id) DESC LIMIT ${MAX_HOLDER_BUCKETS}`, exec);
+        if (bucketQ.available) {
+          buckets = bucketQ.records.map((r2) => {
+            const row = r2;
+            return {
+              profileId: row.pid === void 0 || row.pid === null ? null : String(row.pid),
+              profileName: row.pname === void 0 || row.pname === null ? null : String(row.pname),
+              holders: Number(row.holders ?? row.expr1 ?? 0)
+            };
+          });
+        }
+      }
+      const detailQ = await liveQuery(org, `SELECT Id, AssigneeId, Assignee.Name, Assignee.Username, Assignee.IsActive, Assignee.Profile.Name, ExpirationDate, PermissionSetGroupId, PermissionSetGroup.DeveloperName FROM PermissionSetAssignment WHERE ${where}${afterClause} ORDER BY Id LIMIT ${limit}`, exec);
+      if (!detailQ.available)
+        return err(UNAVAILABLE_ERROR("PermissionSetAssignment", org, detailQ.reason));
+      const rows = detailQ.records.map(toPermsetHolder);
+      return ok({
+        data: fitPermsetHolders({
+          target,
+          totalAssignees,
+          activeAssignees,
+          expiredExcluded,
+          trust: liveTrust(queriedAt)
+        }, rows, viaGroups.map((g2) => g2.name), buckets),
+        vaultState: livePlaneVaultState(ctx)
+      });
+    };
+    splitHolders = (rows, groupNames) => {
+      const direct = rows.filter((h2) => h2.viaGroup === null);
+      const byGroup = /* @__PURE__ */ new Map();
+      for (const h2 of rows) {
+        if (h2.viaGroup === null)
+          continue;
+        const list = byGroup.get(h2.viaGroup) ?? [];
+        list.push(h2);
+        byGroup.set(h2.viaGroup, list);
+      }
+      const ordered = [
+        ...groupNames.filter((g2) => byGroup.has(g2)),
+        ...[...byGroup.keys()].filter((g2) => !groupNames.includes(g2))
+      ];
+      return {
+        direct,
+        via: ordered.map((g2) => ({ groupName: g2, holders: byGroup.get(g2) ?? [] }))
+      };
+    };
+    fitPermsetHolders = (base, allRows, groupNames, buckets) => {
+      let slice = allRows;
+      let byteTrimmed = false;
+      for (; ; ) {
+        const returned = slice.length;
+        const distinctReturned = new Set(slice.map((h2) => h2.userId)).size;
+        const capped = byteTrimmed || base.totalAssignees > distinctReturned;
+        const last = slice[slice.length - 1];
+        const nextAfterId = capped && last !== void 0 ? last.assignmentId ?? last.userId : void 0;
+        const { direct, via } = splitHolders(slice, groupNames);
+        const shape = {
+          ...base,
+          returned,
+          capped,
+          ...nextAfterId !== void 0 ? { nextAfterId } : {},
+          ...buckets !== void 0 ? { buckets } : {},
+          directHolders: direct,
+          ...groupNames.length > 0 || via.length > 0 ? { viaGroupHolders: via } : {},
+          ...byteTrimmed ? {
+            note: `Detail rows trimmed to ${returned} to stay within the response size limit; totalAssignees (${base.totalAssignees}) is the true count \u2014 page on with afterId.`
+          } : {}
+        };
+        const rendered = renderPermsetHoldersMarkdown(shape);
+        const bytes = Buffer.byteLength(JSON.stringify({ ...shape, rendered }), "utf8");
+        if (bytes <= HOLDERS_BYTE_BUDGET || slice.length <= 1) {
+          return { ...shape, rendered };
+        }
+        slice = slice.slice(0, Math.max(1, Math.floor(slice.length * 0.85)));
+        byteTrimmed = true;
+      }
+    };
+    MAX_ZOMBIE_ROWS = 500;
+    DEFAULT_ZOMBIE_ROWS = 100;
+    ZOMBIE_BYTE_BUDGET = 36e3;
+    ZOMBIE_CLIENT_DIFF_CAP = 2e3;
+    ZOMBIE_ACCOUNTS_DISCLOSURE = 'A "zombie" here still holds every permission its PROFILE grants \u2014 this tool reports "no permission-set/PSG assignments", NOT "no access". Read-only; point-in-time as of queriedAt.';
+    liveZombieAccountsInputSchema = liveEnabledSchema.extend({
+      /** Additionally require last login older than N days (default 0 = ignore
+       *  login age; dormancy alone is sfi.live_inactive_users' job). */
+      minDaysInactive: z2.number().int().min(0).max(3650).optional(),
+      /** Include non-Standard user types (default false — Standard/human only). */
+      includeAllUserTypes: z2.boolean().optional(),
+      /** Max detail rows (default 100, hard cap 500); byte budget may trim further.
+       *  `totalZombies` is always the true count. */
+      limit: z2.number().int().min(1).max(MAX_ZOMBIE_ROWS).optional(),
+      orgAlias: z2.string().min(1).optional()
+    });
+    toZombieUser = (r2) => ({
+      id: String(r2.Id ?? ""),
+      name: String(r2.Name ?? ""),
+      username: String(r2.Username ?? ""),
+      profileName: r2.Profile?.Name ?? null,
+      lastLoginDate: r2.LastLoginDate ?? null,
+      neverLoggedIn: (r2.LastLoginDate ?? null) === null
+    });
+    renderZombieAccountsMarkdown = (data) => {
+      const head = `**${data.totalZombies.toLocaleString("en-US")}** active ${data.criteria.userTypeFilter === "Standard" ? "Standard " : ""}user(s) have login access but ZERO permission-set/PSG assignments` + (data.criteria.cutoff !== null ? ` and no login within ${data.criteria.minDaysInactive} days` : "") + ".";
+      const table = data.users.length === 0 ? "" : `
+
+${mdTable(["User", "Username", "Profile", "Last login"], data.users.map((u2) => [
+        u2.name,
+        u2.username,
+        u2.profileName ?? "\u2014",
+        u2.neverLoggedIn ? "never" : u2.lastLoginDate ?? "\u2014"
+      ]))}`;
+      const cappedLine = data.capped ? `
+
+Showing ${data.returned} of ${data.totalZombies}.` : "";
+      const methodLine = data.method === "client-diff" ? `
+
+Method: client-diff \u2014 the org rejected the single anti-join SOQL, so this was computed by diffing two bounded queries (scan cap ${ZOMBIE_CLIENT_DIFF_CAP} rows each).` : "";
+      return `${head}${table}${cappedLine}${methodLine}
+
+${data.disclosure}
+
+${renderTrustFooter(data.trust)}`;
+    };
+    fitZombieUsers = (base, allUsers, extraNote) => {
+      let slice = allUsers;
+      let byteTrimmed = false;
+      for (; ; ) {
+        const returned = slice.length;
+        const capped = byteTrimmed || base.totalZombies > returned;
+        const noteText = [
+          ...extraNote !== void 0 ? [extraNote] : [],
+          ...byteTrimmed ? [
+            `Detail rows trimmed to ${returned} to stay within the response size limit; totalZombies (${base.totalZombies}) is the true count.`
+          ] : []
+        ].join(" ");
+        const shape = {
+          ...base,
+          returned,
+          capped,
+          users: slice,
+          ...noteText.length > 0 ? { note: noteText } : {}
+        };
+        const rendered = renderZombieAccountsMarkdown(shape);
+        const bytes = Buffer.byteLength(JSON.stringify({ ...shape, rendered }), "utf8");
+        if (bytes <= ZOMBIE_BYTE_BUDGET || slice.length <= 1) {
+          return { ...shape, rendered };
+        }
+        slice = slice.slice(0, Math.max(1, Math.floor(slice.length * 0.85)));
+        byteTrimmed = true;
+      }
+    };
+    liveZombieAccountsHandler = async (ctx, input2, exec = nodeExecFile2) => {
+      const gate = await gateLive(ctx, input2);
+      if (!gate.ok)
+        return gate;
+      const org = gate.value;
+      const queriedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const minDaysInactive = input2.minDaysInactive ?? 0;
+      const limit = input2.limit ?? DEFAULT_ZOMBIE_ROWS;
+      const cutoff = minDaysInactive > 0 ? daysAgoSoql(minDaysInactive) : null;
+      const userTypeClause = input2.includeAllUserTypes ? "" : ` AND UserType = 'Standard'`;
+      const loginClause = cutoff !== null ? ` AND (LastLoginDate < ${cutoff} OR LastLoginDate = null)` : "";
+      const baseWhere = `IsActive = true${userTypeClause}${loginClause}`;
+      const antiJoin = ` AND Id NOT IN (SELECT AssigneeId FROM PermissionSetAssignment WHERE PermissionSet.IsOwnedByProfile = false)`;
+      const criteria = {
+        minDaysInactive,
+        cutoff,
+        userTypeFilter: input2.includeAllUserTypes ? "all" : "Standard"
+      };
+      const detailSelect = `SELECT Id, Name, Username, Profile.Name, LastLoginDate FROM User`;
+      const countQ = await liveQuery(org, `SELECT COUNT() FROM User WHERE ${baseWhere}${antiJoin}`, exec);
+      if (countQ.available) {
+        const detailQ = await liveQuery(org, `${detailSelect} WHERE ${baseWhere}${antiJoin} ORDER BY LastLoginDate ASC NULLS FIRST LIMIT ${limit}`, exec);
+        if (!detailQ.available)
+          return err(UNAVAILABLE_ERROR("User", org, detailQ.reason));
+        const users = detailQ.records.map(toZombieUser);
+        return ok({
+          data: fitZombieUsers({
+            criteria,
+            totalZombies: countQ.total,
+            method: "anti-join",
+            disclosure: ZOMBIE_ACCOUNTS_DISCLOSURE,
+            trust: liveTrust(queriedAt)
+          }, users, void 0),
+          vaultState: livePlaneVaultState(ctx)
+        });
+      }
+      if (isBudgetExhaustedReason(countQ.reason)) {
+        return err({ kind: "invalid-query", message: redactSecrets(countQ.reason ?? "live-query budget exhausted") });
+      }
+      const usersQ = await liveQuery(org, `${detailSelect} WHERE ${baseWhere} ORDER BY LastLoginDate ASC NULLS FIRST LIMIT ${ZOMBIE_CLIENT_DIFF_CAP}`, exec);
+      if (!usersQ.available)
+        return err(UNAVAILABLE_ERROR("User", org, usersQ.reason));
+      const assigneesQ = await liveQuery(org, `SELECT AssigneeId FROM PermissionSetAssignment WHERE PermissionSet.IsOwnedByProfile = false GROUP BY AssigneeId LIMIT ${ZOMBIE_CLIENT_DIFF_CAP}`, exec);
+      if (!assigneesQ.available) {
+        return err(UNAVAILABLE_ERROR("PermissionSetAssignment", org, assigneesQ.reason));
+      }
+      const assigneeIds = new Set(assigneesQ.records.map((r2) => String(r2.AssigneeId ?? "")));
+      const zombies = usersQ.records.map(toZombieUser).filter((u2) => !assigneeIds.has(u2.id) && !assigneeIds.has(u2.id.slice(0, 15)));
+      const scanBounded = usersQ.records.length >= ZOMBIE_CLIENT_DIFF_CAP || assigneesQ.records.length >= ZOMBIE_CLIENT_DIFF_CAP;
+      const extraNote = `Anti-join SOQL was rejected by the org (${redactSecrets(countQ.reason ?? "unknown").slice(0, 120)}); fell back to a client-side diff of two bounded queries.` + (scanBounded ? ` One scan hit its ${ZOMBIE_CLIENT_DIFF_CAP}-row cap, so totalZombies may UNDERCOUNT \u2014 treat it as a lower bound.` : "");
+      return ok({
+        data: fitZombieUsers({
+          criteria,
+          totalZombies: zombies.length,
+          method: "client-diff",
+          disclosure: ZOMBIE_ACCOUNTS_DISCLOSURE,
+          trust: liveTrust(queriedAt)
+        }, zombies.slice(0, limit), extraNote),
+        vaultState: livePlaneVaultState(ctx)
+      });
+    };
+    MAX_MEMBER_ROWS = 500;
+    DEFAULT_MEMBER_ROWS = 100;
+    MEMBERS_BYTE_BUDGET = 36e3;
+    MEMBER_ID_CHUNK = 200;
+    GROUP_MEMBERS_DISCLOSURE = 'Direct membership only by default \u2014 nested public groups and role entries are listed but NOT expanded to users. expandNested: true expands exactly ONE level of nested public groups (stamped expansion: "partial-one-level"); deeper nesting and role-hierarchy subordinates are not enumerated \u2014 never treat this as the full effective membership. Read-only; point-in-time as of queriedAt.';
+    liveGroupMembersInputSchema = liveEnabledSchema.extend({
+      /** Group.DeveloperName or Group.Name (label) — exact match, never a guess. */
+      name: z2.string().min(1),
+      /** What kind of Group `name` names. Default 'auto' matches both Queue and
+       *  Regular (public group); an ambiguous name across both is an honest error. */
+      groupType: z2.enum(["Queue", "Regular", "auto"]).optional(),
+      /** Expand exactly ONE level of nested public groups (default false). Role
+       *  entries are never expanded. */
+      expandNested: z2.boolean().optional(),
+      /** Max direct GroupMember rows fetched (default 100, hard cap 500); a ~36 KB
+       *  byte budget may trim the user page further. `totalDirectMembers` is
+       *  always the TRUE count. */
+      limit: z2.number().int().min(1).max(MAX_MEMBER_ROWS).optional(),
+      orgAlias: z2.string().min(1).optional()
+    });
+    idChunks = (ids) => {
+      const chunks = [];
+      for (let i2 = 0; i2 < ids.length; i2 += MEMBER_ID_CHUNK) {
+        chunks.push(ids.slice(i2, i2 + MEMBER_ID_CHUNK));
+      }
+      return chunks;
+    };
+    resolveMemberUsers = async (org, ids, exec) => {
+      const byId = /* @__PURE__ */ new Map();
+      for (const chunk of idChunks(ids)) {
+        const inList = chunk.map((id) => soqlLiteral(id)).join(", ");
+        const q2 = await liveQuery(org, `SELECT Id, Name, Username, IsActive FROM User WHERE Id IN (${inList})`, exec);
+        if (!q2.available)
+          return err(UNAVAILABLE_ERROR("User", org, q2.reason));
+        for (const r2 of q2.records) {
+          const row = r2;
+          const id = String(row.Id ?? "");
+          byId.set(id, {
+            id,
+            name: String(row.Name ?? ""),
+            username: String(row.Username ?? ""),
+            isActive: row.IsActive === true
+          });
+        }
+      }
+      return ok(byId);
+    };
+    renderGroupMembersMarkdown = (data) => {
+      const kind = data.group.type === "Queue" ? "queue" : "public group";
+      const lines = [
+        `### Members of ${kind} \`${data.group.developerName}\``,
+        "",
+        `**${data.totalDirectMembers.toLocaleString("en-US")}** direct member entr${data.totalDirectMembers === 1 ? "y" : "ies"} (${data.users.length} user(s), ${data.nestedGroups.length} nested group(s), ${data.roles.length} role(s) on this page).`
+      ];
+      if (data.supportedObjects !== void 0) {
+        lines.push("", data.supportedObjects.length > 0 ? `**Can own:** ${data.supportedObjects.join(", ")}` : "**Can own:** (no QueueSobject rows \u2014 this queue supports no objects)");
+      }
+      if (data.users.length > 0) {
+        lines.push("", "**Users**", "", mdTable(["User", "Username", "Active"], data.users.map((u2) => [u2.name, u2.username, u2.isActive ? "yes" : "no"])));
+      }
+      for (const g2 of data.nestedGroups) {
+        lines.push("", `**Nested group \`${g2.name}\`** (${g2.type}${g2.members === void 0 ? " \u2014 not expanded" : ""})`);
+        if (g2.members !== void 0) {
+          lines.push("", g2.members.length > 0 ? mdTable(["User", "Username", "Active"], g2.members.map((u2) => [u2.name, u2.username, u2.isActive ? "yes" : "no"])) : "(no direct users)");
+          if ((g2.unexpandedNestedCount ?? 0) > 0) {
+            lines.push("", `${g2.unexpandedNestedCount} nested group/role member(s) inside \`${g2.name}\` were NOT expanded (one-level limit).`);
+          }
+        }
+      }
+      if (data.roles.length > 0) {
+        lines.push("", "**Roles** (never expanded to users)", "", mdTable(["Role", "Includes subordinates"], data.roles.map((r2) => [r2.roleName ?? r2.id, r2.includesSubordinates ? "yes" : "no"])));
+      }
+      lines.push("", data.vaultDeclaredMemberCount === null ? "Vault cross-check: no declared member count in the vault for this group (membership is runtime data)." : `Vault cross-check: vault declared **${data.vaultDeclaredMemberCount}** member(s) at last refresh vs **${data.liveDirectMemberCount}** live direct member(s) \u2014 drift: ${data.drift ? "YES" : "no"}.`);
+      if (data.capped) {
+        lines.push("", `Showing ${data.returned} of ${data.totalDirectMembers} direct member(s).`);
+      }
+      lines.push("", data.disclosure, "", renderTrustFooter(data.trust));
+      return lines.join("\n");
+    };
+    fitGroupMembers = (base, allUsers, pageEntryCount, extraNote) => {
+      let slice = allUsers;
+      let byteTrimmed = false;
+      for (; ; ) {
+        const returned = pageEntryCount - (allUsers.length - slice.length);
+        const capped = byteTrimmed || base.totalDirectMembers > pageEntryCount;
+        const noteText = [
+          ...extraNote !== void 0 ? [extraNote] : [],
+          ...byteTrimmed ? [
+            `User rows trimmed to ${slice.length} to stay within the response size limit; totalDirectMembers (${base.totalDirectMembers}) is the true count.`
+          ] : []
+        ].join(" ");
+        const shape = {
+          ...base,
+          returned,
+          capped,
+          users: slice,
+          ...noteText.length > 0 ? { note: noteText } : {}
+        };
+        const rendered = renderGroupMembersMarkdown(shape);
+        const bytes = Buffer.byteLength(JSON.stringify({ ...shape, rendered }), "utf8");
+        if (bytes <= MEMBERS_BYTE_BUDGET || slice.length <= 1) {
+          return { ...shape, rendered };
+        }
+        slice = slice.slice(0, Math.max(1, Math.floor(slice.length * 0.85)));
+        byteTrimmed = true;
+      }
+    };
+    liveGroupMembersHandler = async (ctx, input2, exec = nodeExecFile2) => {
+      const gate = await gateLive(ctx, input2);
+      if (!gate.ok)
+        return gate;
+      const org = gate.value;
+      const queriedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const limit = input2.limit ?? DEFAULT_MEMBER_ROWS;
+      const lit = soqlLiteral(input2.name);
+      const typeClause = input2.groupType === void 0 || input2.groupType === "auto" ? `Type IN ('Queue', 'Regular')` : `Type = '${input2.groupType}'`;
+      const resolveQ = await liveQuery(org, `SELECT Id, Name, DeveloperName, Type FROM Group WHERE (DeveloperName = ${lit} OR Name = ${lit}) AND ${typeClause} LIMIT 3`, exec);
+      if (!resolveQ.available)
+        return err(UNAVAILABLE_ERROR("Group", org, resolveQ.reason));
+      if (resolveQ.records.length === 0) {
+        return err({
+          kind: "component-not-found",
+          message: `No queue or public group named '${input2.name}' in the live org (probed Group by exact DeveloperName/Name${input2.groupType && input2.groupType !== "auto" ? `, Type ${input2.groupType}` : ""}). Check the API name \u2014 sfi.resolve can fix typos against the vault.`
+        });
+      }
+      if (resolveQ.records.length > 1) {
+        const kinds = resolveQ.records.map((r2) => String(r2.Type ?? "?")).join(" + ");
+        return err({
+          kind: "invalid-query",
+          message: `'${input2.name}' matches ${resolveQ.records.length} Group records in the live org (${kinds}) \u2014 refusing to guess. Pass groupType ('Queue' | 'Regular') or the exact DeveloperName.`
+        });
+      }
+      const groupRow = resolveQ.records[0];
+      const group = {
+        id: String(groupRow.Id ?? ""),
+        name: String(groupRow.Name ?? groupRow.DeveloperName ?? input2.name),
+        developerName: String(groupRow.DeveloperName ?? input2.name),
+        type: groupRow.Type === "Queue" ? "Queue" : "Regular"
+      };
+      const countQ = await liveQuery(org, `SELECT COUNT() FROM GroupMember WHERE GroupId = '${group.id}'`, exec);
+      if (!countQ.available)
+        return err(UNAVAILABLE_ERROR("GroupMember", org, countQ.reason));
+      const totalDirectMembers = countQ.total;
+      const membersQ = await liveQuery(org, `SELECT Id, UserOrGroupId FROM GroupMember WHERE GroupId = '${group.id}' ORDER BY Id LIMIT ${limit}`, exec);
+      if (!membersQ.available)
+        return err(UNAVAILABLE_ERROR("GroupMember", org, membersQ.reason));
+      const memberIds = membersQ.records.map((r2) => String(r2.UserOrGroupId ?? ""));
+      const directUserIds = memberIds.filter((id) => id.startsWith("005"));
+      const nestedGroupIds = memberIds.filter((id) => id.startsWith("00G"));
+      const unclassified = memberIds.filter((id) => !id.startsWith("005") && !id.startsWith("00G"));
+      let nestedRows = [];
+      if (nestedGroupIds.length > 0) {
+        for (const chunk of idChunks(nestedGroupIds)) {
+          const inList = chunk.map((id) => soqlLiteral(id)).join(", ");
+          const q2 = await liveQuery(org, `SELECT Id, Name, DeveloperName, Type, RelatedId FROM Group WHERE Id IN (${inList})`, exec);
+          if (!q2.available)
+            return err(UNAVAILABLE_ERROR("Group", org, q2.reason));
+          nestedRows = nestedRows.concat(q2.records);
+        }
+      }
+      const roleRows = nestedRows.filter((r2) => String(r2.Type ?? "").startsWith("Role"));
+      const publicNestedRows = nestedRows.filter((r2) => !String(r2.Type ?? "").startsWith("Role"));
+      const roleNameById = /* @__PURE__ */ new Map();
+      const relatedIds = roleRows.map((r2) => String(r2.RelatedId ?? "")).filter((id) => id.length > 0);
+      if (relatedIds.length > 0) {
+        const inList = relatedIds.map((id) => soqlLiteral(id)).join(", ");
+        const q2 = await liveQuery(org, `SELECT Id, Name FROM UserRole WHERE Id IN (${inList})`, exec);
+        if (!q2.available && isBudgetExhaustedReason(q2.reason)) {
+          return err({ kind: "invalid-query", message: redactSecrets(q2.reason ?? "live-query budget exhausted") });
+        }
+        if (q2.available) {
+          for (const r2 of q2.records) {
+            const row = r2;
+            roleNameById.set(String(row.Id ?? ""), String(row.Name ?? ""));
+          }
+        }
+      }
+      const roles = roleRows.map((r2) => {
+        const relatedId = String(r2.RelatedId ?? "");
+        return {
+          id: String(r2.Id ?? ""),
+          roleName: roleNameById.get(relatedId) ?? null,
+          type: String(r2.Type ?? "Role"),
+          includesSubordinates: String(r2.Type ?? "").startsWith("RoleAndSubordinates")
+        };
+      });
+      const expandNested = input2.expandNested === true;
+      const nestedMembersByGroup = /* @__PURE__ */ new Map();
+      if (expandNested && publicNestedRows.length > 0) {
+        const inList = publicNestedRows.map((r2) => soqlLiteral(String(r2.Id ?? ""))).join(", ");
+        const q2 = await liveQuery(org, `SELECT GroupId, UserOrGroupId FROM GroupMember WHERE GroupId IN (${inList}) ORDER BY Id LIMIT ${MAX_MEMBER_ROWS}`, exec);
+        if (!q2.available)
+          return err(UNAVAILABLE_ERROR("GroupMember", org, q2.reason));
+        for (const r2 of q2.records) {
+          const row = r2;
+          const gid = String(row.GroupId ?? "");
+          const list = nestedMembersByGroup.get(gid) ?? [];
+          list.push(String(row.UserOrGroupId ?? ""));
+          nestedMembersByGroup.set(gid, list);
+        }
+      }
+      const nestedUserIds = [...nestedMembersByGroup.values()].flat().filter((id) => id.startsWith("005"));
+      const allUserIds = [.../* @__PURE__ */ new Set([...directUserIds, ...nestedUserIds])];
+      const usersR = await resolveMemberUsers(org, allUserIds, exec);
+      if (!usersR.ok)
+        return usersR;
+      const userById = usersR.value;
+      const toUser = (id) => userById.get(id) ?? userById.get(id.slice(0, 15)) ?? { id, name: "", username: "", isActive: false };
+      const nestedGroups = publicNestedRows.map((r2) => {
+        const id = String(r2.Id ?? "");
+        const base = {
+          id,
+          name: String(r2.DeveloperName ?? r2.Name ?? id),
+          type: String(r2.Type ?? "Regular")
+        };
+        if (!expandNested)
+          return base;
+        const memberIdsOfGroup = nestedMembersByGroup.get(id) ?? [];
+        const userMembers = memberIdsOfGroup.filter((m2) => m2.startsWith("005")).map(toUser);
+        const unexpanded = memberIdsOfGroup.length - userMembers.length;
+        return {
+          ...base,
+          members: userMembers,
+          ...unexpanded > 0 ? { unexpandedNestedCount: unexpanded } : {}
+        };
+      });
+      let supportedObjects;
+      if (group.type === "Queue") {
+        const q2 = await liveQuery(org, `SELECT SobjectType FROM QueueSobject WHERE QueueId = '${group.id}'`, exec);
+        if (!q2.available && isBudgetExhaustedReason(q2.reason)) {
+          return err({ kind: "invalid-query", message: redactSecrets(q2.reason ?? "live-query budget exhausted") });
+        }
+        if (q2.available) {
+          supportedObjects = q2.records.map((r2) => String(r2.SobjectType ?? "")).filter((s2) => s2.length > 0).sort();
+        }
+      }
+      let vaultDeclaredMemberCount = null;
+      if (ctx.graph !== void 0 && ctx.graph !== null) {
+        const vaultId = `${group.type === "Queue" ? "Queue" : "Group"}:${group.developerName}`;
+        const nodeR = await getNodeById(ctx.graph, vaultId);
+        if (nodeR.ok && nodeR.value !== null) {
+          const declared = nodeR.value.properties["memberCount"];
+          if (typeof declared === "number")
+            vaultDeclaredMemberCount = declared;
+        }
+      }
+      const drift = vaultDeclaredMemberCount !== null && vaultDeclaredMemberCount !== totalDirectMembers;
+      const extraNote = unclassified.length > 0 ? `${unclassified.length} GroupMember row(s) carry an id prefix that is neither User (005) nor Group (00G) \u2014 listed in no bucket, but counted in totalDirectMembers.` : void 0;
+      return ok({
+        data: fitGroupMembers({
+          group,
+          ...supportedObjects !== void 0 ? { supportedObjects } : {},
+          totalDirectMembers,
+          nestedGroups,
+          roles,
+          expansion: expandNested ? "partial-one-level" : "none",
+          vaultDeclaredMemberCount,
+          liveDirectMemberCount: totalDirectMembers,
+          drift,
+          disclosure: GROUP_MEMBERS_DISCLOSURE,
+          trust: liveTrust(queriedAt)
+        }, directUserIds.map(toUser), memberIds.length, extraNote),
+        vaultState: livePlaneVaultState(ctx)
+      });
+    };
+    MAX_USER_PERMSET_ROWS = 500;
+    DEFAULT_USER_PERMSET_ROWS = 200;
+    USER_PERMSETS_BYTE_BUDGET = 36e3;
+    USER_PERMSETS_DISCLOSURE = "Live = WHICH grantors this user holds right now (point-in-time as of queriedAt); vault sfi.effective_permissions = WHAT those grantors grant \u2014 pair them for a dual-provenance answer. The PROFILE grants permissions too: it is named here but its contents are not enumerated. Read-only.";
+    liveUserPermsetsInputSchema = liveEnabledSchema.extend({
+      /** Exact Username (preferred — unique) or exact User.Name. An ambiguous name
+       *  returns an honest candidate list, never a guess. */
+      user: z2.string().min(1),
+      /** Max assignment rows (default 200, hard cap 500); a ~36 KB byte budget may
+       *  trim further. `totalAssignments` is always the TRUE count. */
+      limit: z2.number().int().min(1).max(MAX_USER_PERMSET_ROWS).optional(),
+      orgAlias: z2.string().min(1).optional()
+    });
+    renderUserPermsetsMarkdown = (data) => {
+      const direct = data.directPermsets.length;
+      const via = data.viaGroups.reduce((n2, g2) => n2 + g2.permsets.length, 0);
+      const lines = [
+        `### Live permission-set holdings for ${data.user.name} (\`${data.user.username}\`)`,
+        "",
+        `Profile: **${data.user.profileName ?? "(none)"}**${data.user.isActive ? "" : " \u2014 user is INACTIVE"}.`,
+        "",
+        `**${data.totalAssignments.toLocaleString("en-US")}** assignment(s) (${direct} direct, ${via} via group(s) on this page)` + (data.expiredExcluded > 0 ? `; ${data.expiredExcluded} expired assignment(s) excluded` : "") + "."
+      ];
+      const grantRows = (grants) => mdTable(["Permission set", "Label", "Expires"], grants.map((g2) => [g2.permissionSetName, g2.permissionSetLabel ?? "\u2014", g2.expirationDate ?? "\u2014"]));
+      if (data.directPermsets.length > 0) {
+        lines.push("", "**Direct permission sets**", "", grantRows(data.directPermsets));
+      }
+      for (const g2 of data.viaGroups) {
+        lines.push("", `**Via permission set group \`${g2.groupName}\`**`, "", grantRows(g2.permsets));
+      }
+      if (data.capped) {
+        lines.push("", `Showing ${data.returned} of ${data.totalAssignments} assignment(s).`);
+      }
+      lines.push("", data.disclosure, "", renderTrustFooter(data.trust));
+      return lines.join("\n");
+    };
+    fitUserPermsets = (base, allRows) => {
+      let slice = allRows;
+      let byteTrimmed = false;
+      for (; ; ) {
+        const returned = slice.length;
+        const capped = byteTrimmed || base.totalAssignments > returned;
+        const direct = [];
+        const byGroup = /* @__PURE__ */ new Map();
+        for (const row of slice) {
+          const { viaGroup, ...grant } = row;
+          if (viaGroup === null) {
+            direct.push(grant);
+          } else {
+            const list = byGroup.get(viaGroup) ?? [];
+            list.push(grant);
+            byGroup.set(viaGroup, list);
+          }
+        }
+        const shape = {
+          ...base,
+          returned,
+          capped,
+          directPermsets: direct,
+          viaGroups: [...byGroup.entries()].map(([groupName, permsets]) => ({ groupName, permsets })),
+          ...byteTrimmed ? {
+            note: `Assignment rows trimmed to ${returned} to stay within the response size limit; totalAssignments (${base.totalAssignments}) is the true count.`
+          } : {}
+        };
+        const rendered = renderUserPermsetsMarkdown(shape);
+        const bytes = Buffer.byteLength(JSON.stringify({ ...shape, rendered }), "utf8");
+        if (bytes <= USER_PERMSETS_BYTE_BUDGET || slice.length <= 1) {
+          return { ...shape, rendered };
+        }
+        slice = slice.slice(0, Math.max(1, Math.floor(slice.length * 0.85)));
+        byteTrimmed = true;
+      }
+    };
+    liveUserPermsetsHandler = async (ctx, input2, exec = nodeExecFile2) => {
+      const gate = await gateLive(ctx, input2);
+      if (!gate.ok)
+        return gate;
+      const org = gate.value;
+      const queriedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const limit = input2.limit ?? DEFAULT_USER_PERMSET_ROWS;
+      const lit = soqlLiteral(input2.user);
+      const nowLiteral = soqlDateTime(/* @__PURE__ */ new Date());
+      const userSelect = `SELECT Id, Name, Username, IsActive, Profile.Name FROM User`;
+      let userRow;
+      const byUsername = await liveQuery(org, `${userSelect} WHERE Username = ${lit} LIMIT 2`, exec);
+      if (!byUsername.available)
+        return err(UNAVAILABLE_ERROR("User", org, byUsername.reason));
+      if (byUsername.records.length === 1) {
+        userRow = byUsername.records[0];
+      } else {
+        const byName = await liveQuery(org, `${userSelect} WHERE Name = ${lit} LIMIT 5`, exec);
+        if (!byName.available)
+          return err(UNAVAILABLE_ERROR("User", org, byName.reason));
+        if (byName.records.length === 0) {
+          return err({
+            kind: "component-not-found",
+            message: `No user with exact Username or Name '${input2.user}' in the live org. Usernames are unique \u2014 prefer the full Username.`
+          });
+        }
+        if (byName.records.length > 1) {
+          const candidates = byName.records.map((r2) => String(r2.Username ?? "")).filter((u2) => u2.length > 0).join(", ");
+          return err({
+            kind: "invalid-query",
+            message: `'${input2.user}' matches ${byName.records.length} users in the live org \u2014 refusing to guess. Pass the exact Username. Candidates: ${candidates}.`
+          });
+        }
+        userRow = byName.records[0];
+      }
+      const user = {
+        id: String(userRow.Id ?? ""),
+        name: String(userRow.Name ?? ""),
+        username: String(userRow.Username ?? ""),
+        isActive: userRow.IsActive === true,
+        profileName: userRow.Profile?.Name ?? null
+      };
+      const scope = `AssigneeId = '${user.id}' AND PermissionSet.IsOwnedByProfile = false`;
+      const notExpiredClause = ` AND (ExpirationDate = null OR ExpirationDate >= ${nowLiteral})`;
+      const countQ = await liveQuery(org, `SELECT COUNT() FROM PermissionSetAssignment WHERE ${scope}${notExpiredClause}`, exec);
+      if (!countQ.available) {
+        return err(UNAVAILABLE_ERROR("PermissionSetAssignment", org, countQ.reason));
+      }
+      const totalAssignments = countQ.total;
+      const expiredQ = await liveQuery(org, `SELECT COUNT() FROM PermissionSetAssignment WHERE ${scope} AND ExpirationDate < ${nowLiteral}`, exec);
+      const expiredExcluded = expiredQ.available ? expiredQ.total : 0;
+      const detailQ = await liveQuery(org, `SELECT Id, PermissionSet.Name, PermissionSet.Label, PermissionSetGroupId, PermissionSetGroup.DeveloperName, ExpirationDate FROM PermissionSetAssignment WHERE ${scope}${notExpiredClause} ORDER BY Id LIMIT ${limit}`, exec);
+      if (!detailQ.available) {
+        return err(UNAVAILABLE_ERROR("PermissionSetAssignment", org, detailQ.reason));
+      }
+      const rows = detailQ.records.map((r2) => ({
+        assignmentId: String(r2.Id ?? ""),
+        permissionSetName: String(r2.PermissionSet?.Name ?? ""),
+        permissionSetLabel: r2.PermissionSet?.Label ?? null,
+        expirationDate: r2.ExpirationDate ?? null,
+        viaGroup: r2.PermissionSetGroupId ? r2.PermissionSetGroup?.DeveloperName ?? String(r2.PermissionSetGroupId) : null
+      })).sort((a2, b2) => a2.permissionSetName.localeCompare(b2.permissionSetName));
+      return ok({
+        data: fitUserPermsets({
+          user,
+          totalAssignments,
+          expiredExcluded,
+          disclosure: USER_PERMSETS_DISCLOSURE,
+          trust: liveTrust(queriedAt)
+        }, rows),
+        vaultState: livePlaneVaultState(ctx)
+      });
+    };
   }
 });
 
@@ -24806,6 +25667,73 @@ var init_intent_router = __esm({
           /\bwhat_if_remove_picklist_value\b/
         ]
       },
+      // === R3 §5b — what-if CHANGE-TYPE WHITELIST honest routes ================
+      // The what_if_* simulators cover a fixed change-type list (field type /
+      // required / picklist value, flow deactivation, trigger disable, method
+      // signature, profile merge/split). A what-if ask about a change type with
+      // NO simulator (remove a record type, change a layout assignment, change a
+      // flow variable's type) must not be absorbed by the nearest-neighbor
+      // what_if_* — these rules catch those shapes FIRST and route the honest
+      // dependency read (get_impact & friends) with an explicit no-simulator
+      // disclosure, mirroring `permission-set-deactivation-impact`.
+      {
+        intent: "record-type-removal-impact",
+        plane: "vault",
+        tools: ["sfi.resolve", "sfi.get_impact", "sfi.recordtype_availability"],
+        liveRequired: false,
+        needsResolve: true,
+        reason: "No what_if simulator exists for removing a record type, so this routes honestly to the dependency read: get_impact surfaces the flows, layouts, validation rules, and profiles referencing the record type, and recordtype_availability shows who can see it today \u2014 the truthful stand-in for a removal blast radius, not a fabricated simulation.",
+        patterns: [
+          /\b(?:remov\w+|delet\w+|dropp?\w*|consolidat\w+|retir\w+)\b[^.?!]{0,50}\brecord\s+types?\b/,
+          /\brecord\s+types?\b[^.?!]{0,50}\b(?:is|are|was|were|gets?|being)\s+(?:removed|deleted|dropped|consolidated|retired)\b/
+        ]
+      },
+      {
+        intent: "layout-assignment-change-impact",
+        plane: "vault",
+        tools: ["sfi.resolve", "sfi.layout_assignments", "sfi.get_impact"],
+        liveRequired: false,
+        needsResolve: true,
+        reason: "No what_if simulator exists for changing a page-layout assignment, so this routes honestly to the current state: layout_assignments shows the Profile \xD7 RecordType assignments the change would rewire, plus get_impact for the dependency surface \u2014 a lookup plus impact read, not a fabricated simulation.",
+        patterns: [
+          /\b(?:chang\w+|swapp?\w*|reassign\w*|switch\w*)\b[^.?!]{0,60}\blayout\s+assignments?\b/,
+          /\bwhat\s+(?:if|happens|breaks)\b[^.?!]{0,80}\blayout\s+assignments?\b/
+        ]
+      },
+      {
+        intent: "flow-variable-type-change-impact",
+        plane: "vault",
+        tools: ["sfi.resolve", "sfi.get_impact", "sfi.explain_flow"],
+        liveRequired: false,
+        needsResolve: true,
+        reason: "No what_if simulator models changing a flow variable's type (e.g. single record to collection), so this routes honestly to the callers: get_impact surfaces the flows/processes invoking it (whose passed values a type change breaks), and explain_flow the variable's uses inside \u2014 an interface-impact read, not a fabricated simulation.",
+        patterns: [
+          /\b(?:input|output)\s+variable\b[^.?!]{0,60}\btype\b/,
+          /\bvariable\s+type\b[^.?!]{0,60}\bflow\b/,
+          /\bflow\b[^.?!]{0,60}\bvariable\s+type\b/
+        ]
+      },
+      {
+        // R3 §5b — ENUMERATION-vs-ID gate: `cpq_rule_chain` and
+        // `cpq_quote_template_breakdown` REQUIRE a specific canonical id, so an
+        // org-wide ask ("map the whole CPQ rule chain", "what quote template does
+        // the org use?") must route the ENUMERATION path — the id-free dependency
+        // map plus list_components — never commit an id-required tool without an
+        // id. Hoisted ABOVE the call-graph/"map the chain" family and the generic
+        // `cpq` rule (first-match): only org-wide CPQ phrasings land here; a
+        // named rule/template still gets the per-id chain tools.
+        intent: "cpq-enumeration",
+        plane: "vault",
+        tools: ["sfi.cpq_dependency_map", "sfi.list_components"],
+        liveRequired: false,
+        needsResolve: false,
+        reason: "Org-wide CPQ enumeration: cpq_dependency_map maps the whole rule/template surface with no id needed, and list_components enumerates the CPQ rules/templates themselves. The per-id tools (cpq_rule_chain, cpq_quote_template_breakdown) need a specific named rule or template \u2014 pick one from the enumeration first.",
+        patterns: [
+          /\bmap\s+the\b[^.?!]{0,40}\bcpq\b|\bcpq\b[^.?!]{0,40}\brule\s+chain\b[^.?!]{0,60}\b(?:evaluation\s+order|all|every|org-?wide|whole)\b/,
+          /\b(?:what|which)\s+(?:cpq\s+)?quote\s+templates?\b[^.?!]{0,50}\b(?:do(?:es)?\s+(?:we|the\s+org)|org)\s*use\b/,
+          /\b(?:all|every|list)\b[^.?!]{0,30}\b(?:price|product|discount)\s+rules?\b[^.?!]{0,50}\b(?:evaluation\s+order|and\s+their)\b/
+        ]
+      },
       {
         intent: "async-chain-depth",
         plane: "vault",
@@ -25084,25 +26012,50 @@ var init_intent_router = __esm({
           /\bhow\s+many\s+users?\b.*\bon\b.*\bprofiles?\b/
         ]
       },
+      {
+        // ENGINE-ARC §2c (NEW arm): "zombie accounts" — active users with login
+        // access but ZERO permission-set/PSG assignments. This is the User × PSA
+        // anti-join (sfi.live_zombie_accounts), an explicit DELTA over
+        // live_inactive_users: dormancy-only phrasings ("who hasn't logged in")
+        // carry no permission-set-absence noun and fall through to inactive-users.
+        // Every pattern requires either the literal "zombie" or a
+        // no/zero/without + permission-set frame, so genuine holder-roster asks
+        // ("which users have permission set X" — no negative) never land here.
+        // Sits BEFORE profile-user-roster so "users with nothing assigned beyond
+        // their profile" is not stolen by the profile-roster grammar.
+        intent: "zombie-accounts",
+        plane: "live",
+        tools: ["sfi.live_zombie_accounts"],
+        liveRequired: true,
+        needsResolve: false,
+        reason: 'Active users with NO permission-set/PSG assignments is a live User \xD7 PermissionSetAssignment anti-join (live_zombie_accounts). Note: a "zombie" still holds everything its PROFILE grants \u2014 the tool discloses that.',
+        patterns: [
+          /\bzombie\s+(?:accounts?|users?)\b/,
+          // "which active users have no/zero permission sets (assigned)?" /
+          // "users with zero permission set or group assignments" / "can log in
+          // but have no permission set assignments"
+          /\b(?:users?|accounts?)\b[^.?!]{0,50}\b(?:no|zero|without|not\s+any)\b[^.?!]{0,15}\bpermission\s+sets?\b/,
+          // "which users have nothing assigned beyond their profile?"
+          /\bnothing\s+assigned\s+beyond\b[^.?!]{0,25}\bprofiles?\b/,
+          // "login access but no perm sets" (perm-set abbreviation variant)
+          /\b(?:no|zero|without)\b[^.?!]{0,15}\bperm\s+sets?\b/
+        ]
+      },
       {
         // "list everyone with the X profile" is a USER ROSTER ask: user-to-profile
         // assignment is runtime User-record state, not vault metadata — the schema
         // list rule used to claim it via "list ... profiles" and answer with the
-        // Profile METADATA catalog (eval family D). live_group_count genuinely
-        // answers the count side (Users grouped by ProfileId) and
-        // live_inactive_users the login-activity side; the name-by-name roster
-        // itself is disclosed as a partial answer, never papered over.
+        // Profile METADATA catalog (eval family D). ENGINE-ARC §4: the name-by-name
+        // roster IS now built — sfi.live_permset_holders (kind:'profile') lists the
+        // users live; live_group_count keeps the count side and live_inactive_users
+        // the login-activity side. The old partial-answer gap block is DELETED.
         intent: "profile-user-roster",
         plane: "live",
-        tools: ["sfi.live_group_count", "sfi.live_inactive_users"],
+        tools: ["sfi.live_permset_holders", "sfi.live_group_count", "sfi.live_inactive_users"],
         liveRequired: true,
         needsResolve: false,
-        reason: "Which users hold a profile is runtime User-record state: count them live grouped by ProfileId (live_group_count); login-activity detail comes from live_inactive_users.",
-        gap: {
-          category: "profile-user-roster",
-          note: "Partial answer: live_group_count returns user COUNTS per profile and live_inactive_users lists dormant users, but a full name-by-name user roster per profile is not a built capability yet."
-        },
-        suggestArgs: () => ({ objectApiName: "User", groupByField: "ProfileId" }),
+        reason: "Which users hold a profile is runtime User-record state: live_permset_holders (kind: profile) lists the roster name-by-name from the live org; live_group_count covers per-profile counts and live_inactive_users the login-activity side.",
+        suggestArgs: () => ({ kind: "profile" }),
         patterns: [
           /\b(list|show|who\s+are)\b[^.?!]{0,20}\b(everyone|everybody|all\s+(the\s+)?users?|the\s+users?|people)\b[^.?!]{0,40}\b(with|on|assigned|holding|having)\b[^.?!]{0,40}\bprofile\b/,
           /\b(which|what)\s+users?\b[^.?!]{0,40}\b(have|hold|are\s+on|with|assigned)\b[^.?!]{0,40}\bprofile\b/,
@@ -25326,6 +26279,41 @@ var init_intent_router = __esm({
           /\bstandard\s+objects?\b.*\b(at\s+least\s+one\s+)?(apex\s+)?triggers?\b/
         ]
       },
+      {
+        // ENGINE-ARC §4 (NEW arm): runtime queue / public-group MEMBERSHIP asks
+        // ("who's in the Support queue", "members of the X public group", "can the
+        // X queue own Case"). GroupMember rows are runtime state the vault does not
+        // model — sfi.live_group_members reads them live (polymorphic user/group/
+        // role split, QueueSobject supported objects, vault-drift cross-check).
+        // Sits BEFORE group-count, which used to claim "who's in the X queue" with
+        // a generic GROUP BY count; the roster tool now owns that vocabulary.
+        // Boundary notes: "which queues are EMPTY" (declared-metadata hygiene
+        // sweep) stays on empty-queues-groups; the neutral "which queues does
+        // X_Queue route to and who are the members" stays on queue-membership
+        // (vault get_component — declared members); a PSG "member of" ask never
+        // lands here (patterns require the literal queue / public group noun).
+        intent: "queue-group-member-roster",
+        plane: "live",
+        tools: ["sfi.live_group_members"],
+        liveRequired: true,
+        needsResolve: false,
+        reason: "Who is actually IN a queue or public group is runtime GroupMember data \u2014 live_group_members lists the current roster (users, nested groups, roles) from the live org and cross-checks the vault-declared member count.",
+        patterns: [
+          // "who's / who is / who are ... in|on|member of ... the X queue|public group"
+          /\bwho(?:'?s|\s+is|\s+are)?\b[^.?!]{0,30}\b(?:in|on|member\s+of)\b[^.?!]{0,40}\b(?:queues?|public\s+groups?)\b/,
+          // "which users are in the Support queue?"
+          /\b(?:which|what)\s+users?\b[^.?!]{0,30}\b(?:in|on|belong\s+to)\b[^.?!]{0,40}\b(?:queues?|public\s+groups?)\b/,
+          // "members of the X queue" / "list the members of the Y public group"
+          /\bmembers?\s+of\b[^.?!]{0,40}\b(?:queues?|public\s+groups?)\b/,
+          // "the current membership of the X queue"
+          /\bmembership\s+of\b[^.?!]{0,40}\b(?:queues?|public\s+groups?)\b/,
+          // q267: "can the ADA_Team_Queue own Case records?" / "what objects does
+          // the X queue support?" — QueueSobject supported objects.
+          /\bcan\s+(?:the\s+)?\S+\s*queue\s+own\b/,
+          /\bqueues?\b[^.?!]{0,30}\b(?:own|support)\b[^.?!]{0,30}\b(?:case|lead|objects?|records?)\b/,
+          /\bobjects?\s+(?:does|can)\b[^.?!]{0,40}\bqueue\s+(?:support|own)\b/
+        ]
+      },
       {
         intent: "group-count",
         plane: "live",
@@ -25345,10 +26333,10 @@ var init_intent_router = __esm({
           // "how many".
           /\bcount\b[^.?!]{0,60}\bgrouped?\s+by\b/,
           /\bcount\s+of\b[^.?!]{0,60}\bby\b/,
-          /\bcount\b[^.?!]{0,60}\brecords?\s+by\b/,
-          // "who's in the ADA Team Queue" — queue/public-group membership is a
-          // live GroupMember read; the vault holds the queue definition only.
-          /\bwho(?:'?s|\s+is|\s+are)?\b[^.?!]{0,40}\bin\s+the\b[^.?!]{0,50}\b(queues?|public\s+groups?)\b/
+          /\bcount\b[^.?!]{0,60}\brecords?\s+by\b/
+          // NOTE (ENGINE-ARC §4): "who's in the ADA Team Queue" used to land here
+          // as a generic GROUP BY count; the queue-group-member-roster arm ABOVE
+          // now owns that vocabulary with the dedicated live_group_members roster.
         ]
       },
       {
@@ -25825,6 +26813,58 @@ var init_intent_router = __esm({
           /\brecord\s?type\s?id\b[^.?!]{0,60}\b(?:pick|select|choose|create|use)\b/
         ]
       },
+      {
+        // ENGINE-ARC §4 (NEW arm): the REVERSE user→grantors direction — "what
+        // permission sets does USER Jane hold". A different contract from the
+        // holder-roster direction (permset-user-roster below) and from the vault
+        // GRANTS direction: PermissionSetAssignment rows for one assignee are
+        // runtime state, so sfi.live_user_permsets reads them live (direct sets vs
+        // via-PSG, expirations, profile named). The ordered pair with vault
+        // sfi.effective_permissions is deliberate DUAL PROVENANCE: live = WHICH
+        // grantors she holds; vault = WHAT those grantors grant. Sits BEFORE
+        // effective-permissions, which used to first-match these phrasings and
+        // could only describe grants, never the user's actual assignments.
+        intent: "user-permset-holdings",
+        plane: "live",
+        tools: ["sfi.live_user_permsets", "sfi.effective_permissions"],
+        liveRequired: true,
+        needsResolve: false,
+        reason: "What a named USER holds (their PermissionSetAssignment rows) is runtime state: live_user_permsets lists the direct sets and via-PSG assignments from the live org; effective_permissions then expands what those grantors grant (dual provenance).",
+        patterns: [
+          // Permission sets assigned to a named user (moved here from
+          // effective-permissions — the router used to first-match these to the
+          // vault GRANTS tool, which cannot know a user's assignments).
+          /\bpermission\s+sets?\b.*\bassigned\b.*\buser\b/,
+          /\bwhat\s+permission\s+sets?\b.*\bassigned\b/,
+          // "what permission sets does Jane Doe have / hold" — requires the
+          // PERMISSION SET(S) noun phrase, so "what permissions does the X profile
+          // have" (grants direction) stays on effective-permissions. The
+          // `(?!\s+group)` lookahead keeps "which permission set GROUPS are
+          // assigned to nobody" on the unassigned-permset-groups hygiene arm.
+          /\b(?:what|which)\s+(?:permission\s+sets?|perm\s+sets?)(?!\s+group)\b[^.?!]{0,20}\b(?:does|do|is|are)\b[^.?!]{0,50}\b(?:have|hold|holds|assigned|carry)\b/,
+          // "which permission set groups is <UserName> a member of?" — anchored on
+          // the literal "member of" so "which PSGs are assigned to NOBODY" (the
+          // unassigned-permset-groups hygiene ask, a later rule) is never stolen.
+          // [^?!] (not [^.?!]): usernames are email-shaped and contain dots.
+          /\bwhich\s+permission\s+set\s+groups?\s+(?:is|are)\b[^?!]{0,60}\bmember\s+of\b/,
+          // "which permission sets is jane.doe@example.com assigned right now?" —
+          // the grantee token sits between is/are and "assigned"; \S+ spans the
+          // email-shaped username that clause-bounded classes cannot.
+          /\bpermission\s+sets?\s+(?:is|are)\s+\S+(?:\s+\S+)?\s+assigned\b/,
+          // "what does the user Jane hold — direct sets and via groups?"
+          /\bwhat\s+does\s+(?:the\s+)?user\b[^.?!]{0,40}\bhold\b/,
+          // "show me every permission set assigned to <UserName>" — the grantee is
+          // named after "assigned to" (holder-direction phrasings name the SET
+          // after the users noun and never match this). The lookahead excludes
+          // "assigned to NOBODY / no one / anyone" — that is the vault
+          // unassigned-permsets hygiene sweep, not a user's holdings.
+          /\b(?:every|all|each)\s+permission\s+sets?\s+assigned\s+to\s+(?!nobody\b|no\s+one\b|noone\b|anyone\b|anybody\b)/,
+          // "list <UserName>'s permission set and PSG assignments"
+          /\S+'s\s+permission\s+sets?\b/,
+          // "does <UserName> have any expiring permission set assignments?"
+          /\bexpir\w+\s+permission\s+set\s+assignments?\b/
+        ]
+      },
       {
         intent: "effective-permissions",
         plane: "vault",
@@ -25838,9 +26878,10 @@ var init_intent_router = __esm({
           // "what permissions does the Sales User profile have" — a top
           // baseline-300 unrouted cluster (P14-ROUTER-goldset-expand).
           /\bwhat\s+permissions?\s+(does|do)\b.*\b(profiles?|permission\s+sets?|users?)\b/,
-          // Permission sets assigned to a named user (baseline-300 gap).
-          /\bpermission\s+sets?\b.*\bassigned\b.*\buser\b/,
-          /\bwhat\s+permission\s+sets?\b.*\bassigned\b/,
+          // NOTE (ENGINE-ARC §4): the "permission sets assigned to a user"
+          // phrasings moved to the user-permset-holdings arm ABOVE — a user's
+          // actual assignments are runtime state (live_user_permsets); this vault
+          // arm keeps the GRANTS direction only.
           // REACH (permissions/access cluster): "does/can the <Named> profile /
           // <Named> perm set have|give|grant|read|edit|create|delete|access|see|
           // change <object>". These name a SPECIFIC granter (a profile/permission
@@ -26111,6 +27152,35 @@ var init_intent_router = __esm({
           /\bhighlights?\b.*\b(vs|versus|full)\b.*\blayout\b/
         ]
       },
+      {
+        // COMPONENT-TYPE CONFUSION (router-v2 R2, type-confusion trap family):
+        // "is <Name> a flow or a trigger?", "is that an Apex class or a flow?",
+        // "the name has 'Trigger' in it but is it actually a test class?", "what
+        // type is that?". The user is unsure WHAT KIND of component a name is —
+        // resolve answers the type question, and the two explainers cover
+        // whichever family it lands on (the stage-5 type guard swaps the
+        // incompatible one once the entity resolves). MUST precede
+        // automation-on-object, whose "triggers … on <object>" pattern otherwise
+        // steals "…an actual trigger on Contact?".
+        intent: "component-type",
+        plane: "vault",
+        tools: ["sfi.resolve", "sfi.explain_flow", "sfi.explain_apex_method"],
+        liveRequired: false,
+        needsResolve: true,
+        reason: "The question asks WHICH KIND of component a name is (flow vs trigger vs Apex class vs test class). Resolve the name to its actual type first; then explain it with the family-appropriate tool \u2014 the resolver output, not the name, decides which.",
+        patterns: [
+          // Two component-family nouns joined by "or" inside one clause:
+          // "is <name>/that/it (actually) a flow … or (an actual) trigger".
+          /\bis\s+(?:that|this|it|[a-z0-9_]+)\s+(?:actually\s+)?(?:an?\s+)?(?:apex(?:\s+(?:class|test\s+class|logging))?|flow|trigger|test\s+class)\b[^.?!]{0,40}\bor\s+(?:an?\s+)?(?:actual(?:ly)?\s+a?\s*)?(?:apex(?:\s+class)?|flow|trigger|test\s+class|something\s+else)/,
+          // Name-vs-nature: "…but is it actually a test class?"
+          /\bbut\s+is\s+(?:it|that)\s+(?:actually\s+)?an?\s+(?:test\s+class|trigger|flow|apex\s+class)\b/,
+          // "what type is that / what type of component is <name>" — `that/this`
+          // only (not `it`), and never when the question names a __c FIELD:
+          // "what type is it?" about CON_...__c asks the field's DATA type, not
+          // the component family (the cov3-029 negative).
+          /^(?!.*__c\b)(?=[\s\S]*\bwhat\s+type\s+(?:is\s+(?:that|this)|of\s+component\s+is)\b)/
+        ]
+      },
       {
         intent: "field-access",
         plane: "vault",
@@ -26314,60 +27384,105 @@ var init_intent_router = __esm({
         ]
       },
       {
-        // HONEST GAP (P0b): PermissionSetGroup assignment is not modeled — there is
-        // no PSG-assignment tool. Rather than fall through to unassigned_permission_
-        // sets (PermissionSet-only, confidently wrong) or fabricate a live
-        // workaround, route to an explicit capability gap. Must sit AFTER
-        // unassigned-permsets: the lookahead above already refuses "permission set
-        // groups", so this rule catches it on the fall-through.
+        // PARTIAL FLIP (ENGINE-ARC §4, was HONEST GAP P0b): PermissionSetGroup
+        // ASSIGNMENT is now answerable live per group — sfi.live_permset_holders
+        // (kind:'permissionSetGroup') returns the true holder count and roster for
+        // a NAMED PSG, so "is PSG X assigned to nobody" is a live zero-holder
+        // check. What is still unbuilt is an enumerate-ALL mode (vault PSG list
+        // minus a live GROUP BY PermissionSetGroupId sweep in one call) — the gap
+        // note is DOWNGRADED to that partial until Deferred-2 ships. Must sit
+        // AFTER unassigned-permsets: the lookahead above already refuses
+        // "permission set groups", so this rule catches it on the fall-through.
         intent: "unassigned-permset-groups",
-        plane: "vault",
-        tools: [],
-        liveRequired: false,
+        plane: "live",
+        tools: ["sfi.live_permset_holders"],
+        liveRequired: true,
         needsResolve: false,
-        reason: "Permission set group assignments are not yet modeled \u2014 capability gap.",
+        reason: "Whether a permission set group is assigned to anyone is runtime PermissionSetAssignment state: live_permset_holders (kind: permissionSetGroup) returns the true holder count per named PSG.",
         gap: {
           category: "unassigned-permset-groups",
-          note: "PermissionSetGroup assignment modeling is not built yet. Use sfi.resolve and manual search until a dedicated tool is available; do not substitute unassigned_permission_sets, which covers PermissionSet only."
+          note: "Partial: live_permset_holders checks ONE named permission set group at a time (a zero effectiveTotal = unassigned). A single-call sweep of ALL PSGs is not built yet \u2014 enumerate the vault PSG list first, then check candidates live. Do not substitute unassigned_permission_sets, which covers PermissionSet only."
         },
+        suggestArgs: () => ({ kind: "permissionSetGroup" }),
         patterns: [
           /\b(unassigned|unused|empty)\b[^.?!]{0,40}\bpermission\s+set\s+groups?\b/,
           /\bpermission\s+set\s+groups?\b[^.?!]{0,40}\b(no\s+one|nobody|unassigned|unused|assigned\s+to\s+nobody)\b/
         ]
       },
       {
-        // HONEST GAP (eval family D): "which USERS have permission set X" is a
-        // holder ROSTER — PermissionSetAssignment is runtime assignment data the
-        // vault does not model, and no live tool answers it yet.
-        // effective_permissions / object_access_audit describe what a permission
-        // set GRANTS, not who HOLDS it, so substituting them would be confidently
-        // wrong. Mirrors the unassigned-permset-groups gap above. The reverse
-        // direction ("what permission sets does user X have") stays on
-        // effective-permissions via first-match.
+        // FULL FLIP (ENGINE-ARC §4, was HONEST GAP eval family D): "which USERS
+        // have permission set X" is a holder ROSTER — PermissionSetAssignment is
+        // runtime assignment data the vault does not model, and it is now answered
+        // LIVE by sfi.live_permset_holders (kinds permissionSet | permissionSetGroup
+        // | profile | auto; PSG-trap-aware: direct holders vs via-group holders,
+        // deduped effectiveTotal). The gap block is DELETED. The
+        // do-not-substitute warning stays in `reason`: effective_permissions /
+        // object_access_audit describe what a permission set GRANTS, not who HOLDS
+        // it. The reverse direction ("what permission sets does user X have") is
+        // the user-permset-holdings arm (live_user_permsets).
         intent: "permset-user-roster",
-        plane: "vault",
-        tools: [],
-        liveRequired: false,
+        plane: "live",
+        tools: ["sfi.live_permset_holders"],
+        liveRequired: true,
+        needsResolve: false,
+        reason: "Which users hold a permission set is runtime PermissionSetAssignment state: live_permset_holders lists the roster live, including holders via permission set groups. Do not substitute effective_permissions or object_access_audit \u2014 they describe what a permission set GRANTS, not who holds it.",
+        patterns: [
+          // "perm set(s)" / "permset(s)" ride along with the full "permission
+          // set(s)" spelling — q1213 ("who has the View_Fraud_Score_Component
+          // perm set", the design doc's grounding miss) uses the abbreviation,
+          // and the user-permset-holdings arm above already accepts it.
+          /\b(which|what|list)\s+users?\b[^.?!]{0,40}\b(have|hold|with|assigned)\b[^.?!]{0,40}\b(?:permission\s+sets?|perm\s+sets?|permsets?)\b/,
+          /\bwho\s+(has|holds|is\s+assigned)\b[^.?!]{0,50}\b(?:permission\s+sets?|perm\s+sets?|permsets?)\b/,
+          /\b(everyone|everybody|all\s+users?)\b[^.?!]{0,30}\bwith\b[^.?!]{0,40}\b(?:permission\s+sets?|perm\s+sets?|permsets?)\b/,
+          /\busers?\b[^.?!]{0,30}\bassigned\b[^.?!]{0,30}\b(?:permission\s+sets?|perm\s+sets?|permsets?)\b/
+        ]
+      },
+      {
+        // PARTIAL FLIP (ENGINE-ARC §4, was HONEST GAP round-2 q1948/q1559):
+        // "which PSG grants the X custom permission / the Y role" is a
+        // PermissionSetGroup COMPOSITION lookup. live_permset_holders now surfaces
+        // PSG composition live via PermissionSetGroupComponent (probing a
+        // permission SET reports which PSGs contain it), so the roster/containment
+        // half is answerable. The 2-hop chain "which PSG grants custom permission
+        // X" (custom permission → permission set → PSG, q1916) remains an honest
+        // gap — the slimmed note below keeps it — and roles are not granted by
+        // PSGs at all, so substituting object_access_audit / effective_permissions
+        // would still be confidently wrong. Requires the GROUP noun: "which
+        // permission SETS grant edit on X" (no `group`) stays on the real
+        // field/effective-permissions routes.
+        intent: "permset-group-grants",
+        plane: "live",
+        tools: ["sfi.live_permset_holders"],
+        liveRequired: true,
         needsResolve: false,
-        reason: "Which users hold a permission set (PermissionSetAssignment) is not modeled \u2014 capability gap.",
+        reason: "PSG composition is runtime state: live_permset_holders reads PermissionSetGroupComponent live (probe the permission SET to see which PSGs contain it). Roles are never granted by PSGs.",
         gap: {
-          category: "permset-user-roster",
-          note: 'PermissionSetAssignment modeling is not built yet, so "which users have permission set X" cannot be answered. Do not substitute effective_permissions or object_access_audit \u2014 they describe what a permission set GRANTS, not who holds it.'
+          category: "permset-group-grants",
+          note: 'Partial: live_permset_holders surfaces which PSGs CONTAIN a given permission set (PermissionSetGroupComponent). The 2-hop chain "which PSG grants custom permission X" (custom permission \u2192 permission set \u2192 PSG) is still unbuilt \u2014 resolve the custom permission to its granting permission sets in the vault first, then probe each set live. Do not substitute effective_permissions or object_access_audit for the PSG-composition step.'
         },
         patterns: [
-          /\b(which|what|list)\s+users?\b[^.?!]{0,40}\b(have|hold|with|assigned)\b[^.?!]{0,40}\bpermission\s+sets?\b/,
-          /\bwho\s+(has|holds|is\s+assigned)\b[^.?!]{0,50}\bpermission\s+sets?\b/,
-          /\b(everyone|everybody|all\s+users?)\b[^.?!]{0,30}\bwith\b[^.?!]{0,40}\bpermission\s+sets?\b/,
-          /\busers?\b[^.?!]{0,30}\bassigned\b[^.?!]{0,30}\bpermission\s+sets?\b/
+          // Tempered verb→grants gap: "which permission set groups REFERENCE a
+          // permission set that grants X" is a graph-edge read (answerable) — a
+          // reference/contain/include verb between the PSG noun and `grants`
+          // breaks the match, so only the PSG-as-grantor ask gaps. `not` breaks it
+          // too: "why would a PSG NOT grant expected access" is a troubleshooting
+          // ask that stays on its pre-round-2 route (sweep-parity pin).
+          /\b(?:which|what)\s+(?:permission\s+set\s+groups?|psgs?)\b(?:(?!\b(?:references?|referencing|contains?|containing|includes?|including|not)\b)[^.?!]){0,60}\bgrants?\b/,
+          /\b(?:permission\s+set\s+groups?|psgs?)\b(?:(?!\b(?:references?|referencing|contains?|containing|includes?|including|not)\b)[^.?!]){0,40}\bgrants?\b[^.?!]{0,60}\b(?:custom\s+permission|permission|role|access)\b/
         ]
       },
       {
         intent: "empty-queues-groups",
-        plane: "vault",
-        tools: ["sfi.empty_queues_and_groups"],
+        // ENGINE-ARC §4: vault scan stays PRIMARY; sfi.live_group_members is
+        // appended as the optional runtime-verification secondary (declared
+        // metadata can drift from runtime GroupMember rows — the live tool
+        // measures that drift per queue/group). Hybrid like unused-fields:
+        // liveRequired stays false, the vault half answers alone.
+        plane: "hybrid",
+        tools: ["sfi.empty_queues_and_groups", "sfi.live_group_members"],
         liveRequired: false,
         needsResolve: false,
-        reason: "Queues / public groups with no members \u2014 vault membership scan.",
+        reason: "Queues / public groups with no members \u2014 vault membership scan first; live_group_members optionally verifies a candidate against runtime GroupMember rows (declared metadata can drift).",
         patterns: [
           /\b(empty|unused)\b.*\b(queues?|groups?)\b/,
           /\b(queues?|public\s+groups?)\b.*\b(empty|no\s+members?|unused)\b/,
@@ -32080,6 +33195,10 @@ var init_capabilities = __esm({
           "sfi.live_org_limits",
           "sfi.live_inactive_users",
           "sfi.live_license_usage",
+          "sfi.live_permset_holders",
+          "sfi.live_zombie_accounts",
+          "sfi.live_group_members",
+          "sfi.live_user_permsets",
           "sfi.live_report_usage",
           "sfi.live_folder_access",
           "sfi.live_email_template_usage",
@@ -32180,6 +33299,10 @@ var init_capabilities = __esm({
           "sfi.live_org_limits",
           "sfi.live_inactive_users",
           "sfi.live_license_usage",
+          "sfi.live_permset_holders",
+          "sfi.live_zombie_accounts",
+          "sfi.live_group_members",
+          "sfi.live_user_permsets",
           "sfi.live_report_usage",
           "sfi.live_folder_access",
           "sfi.live_email_template_usage",
@@ -34219,19 +35342,72 @@ var init_component_history = __esm({
   }
 });
 
+// ../mcp/dist/src/tools/vault-assignment-disclosure.js
+var USER_ASSIGNMENT_NOT_IN_VAULT, PERMSET_INTERSECTION_NOT_AVAILABLE, SHARING_USER_ENUMERATION_NOT_AVAILABLE, ASSIGNMENT_DATA_LIVE_TOOLS, userAssignmentUnavailable;
+var init_vault_assignment_disclosure = __esm({
+  "../mcp/dist/src/tools/vault-assignment-disclosure.js"() {
+    "use strict";
+    init_src3();
+    USER_ASSIGNMENT_NOT_IN_VAULT = "User and PermissionSetAssignment data are not retrieved into this vault \u2014 which users hold a profile, permission set, or group membership cannot be answered offline. It is answerable via the live plane: run `sfi.live_permset_holders` (who holds a permission set / PSG / profile), `sfi.live_group_members` (who is in a queue / public group), or `sfi.live_user_permsets` (what a named user holds) \u2014 read-only, consent-gated \u2014 or refresh with a PermissionSetAssignment facts capture for offline holder counts.";
+    PERMSET_INTERSECTION_NOT_AVAILABLE = "Which users have multiple permission sets assigned requires PermissionSetAssignment rows (user assignment data not in vault). This tool can list each permission set structurally but cannot name users with both assignments offline. It is answerable via the live plane: `sfi.live_permset_holders` (read-only, consent-gated) lists the holders of each set for the intersection.";
+    SHARING_USER_ENUMERATION_NOT_AVAILABLE = "Sharing rules name group/role targets, but User records and group membership to individual users are not fully available offline \u2014 cannot enumerate every user who effectively receives Edit from a group-based sharing rule without live User / GroupMember / PermissionSetAssignment data. It is answerable via the live plane: `sfi.live_group_members` (read-only, consent-gated) enumerates the current members of a named queue / public group.";
+    ASSIGNMENT_DATA_LIVE_TOOLS = [
+      "sfi.live_permset_holders",
+      "sfi.live_user_permsets",
+      "sfi.live_group_members",
+      "sfi.live_zombie_accounts"
+    ];
+    userAssignmentUnavailable = (ctx) => {
+      const userCov = summarizeCoverage(ctx.manifest, ["User"]);
+      const psaCov = summarizeCoverage(ctx.manifest, ["PermissionSetAssignment"]);
+      return userCov.status !== "complete" || psaCov.status !== "complete";
+    };
+  }
+});
+
 // ../mcp/dist/src/tools/coverage-report.js
 import { z as z25 } from "zod";
-var TOP_UNCOVERED_FAMILIES_CAP, COVERAGE_DISCLOSURE, coverageReportInputSchema, partitionCoverage, coverageReportHandler;
+var TOP_UNCOVERED_FAMILIES_CAP, COVERAGE_DISCLOSURE, coverageReportInputSchema, ASSIGNMENT_DATA_NOT_A_GAP_REASON, buildAssignmentDataCoverage, partitionCoverage, coverageReportHandler;
 var init_coverage_report = __esm({
   "../mcp/dist/src/tools/coverage-report.js"() {
     "use strict";
     init_src();
+    init_src2();
     init_src3();
+    init_live_plane();
+    init_vault_assignment_disclosure();
     TOP_UNCOVERED_FAMILIES_CAP = 10;
     COVERAGE_DISCLOSURE = "Coverage describes what the last `sf project retrieve` requested and returned \u2014 not what exists in the org. A type listed under `notModeled` is not analyzed by this product at all; its absence from any result means 'not checked', never 'none'. Re-run `/sfi-refresh` after widening your retrieve manifest to close a gap. `topUncoveredFamilies` ranks (by skipped-file volume) directories that WERE retrieved but not modeled by an extractor \u2014 a listed family is retrieved-but-not-modeled, never 'absent'.";
     coverageReportInputSchema = z25.object({
       type: z25.string().min(1).optional()
     });
+    ASSIGNMENT_DATA_NOT_A_GAP_REASON = "runtime data object \u2014 by design, not a retrieve gap";
+    buildAssignmentDataCoverage = async (ctx) => {
+      let present = false;
+      let capturedAt = null;
+      try {
+        const rows = await readFacts(ctx.graph, {
+          subjectId: ACTIVE_HOLDERS_COMPLETE_SUBJECT,
+          metric: "activeHolders",
+          limit: 1
+        });
+        const marker = rows.ok ? rows.value[0] : void 0;
+        if (marker !== void 0 && typeof marker.value === "object" && marker.value !== null && marker.value.complete === true) {
+          present = true;
+          capturedAt = marker.capturedAt;
+        }
+      } catch {
+      }
+      const liveConsent = (await resolveLiveAccess(ctx.manifest.sourceOrg)).allowed;
+      return {
+        vaultModeled: false,
+        reason: ASSIGNMENT_DATA_NOT_A_GAP_REASON,
+        liveTools: ASSIGNMENT_DATA_LIVE_TOOLS,
+        liveConsent,
+        factsCounts: { present, capturedAt },
+        rendered: `Runtime assignment data: not in vault (by design). Live: ${liveConsent ? "available" : "consent-needed"} (${ASSIGNMENT_DATA_LIVE_TOOLS.join(", ")}). Offline counts snapshot: ${present && capturedAt !== null ? `as of ${capturedAt}` : "none"}.`
+      };
+    };
     partitionCoverage = (entries) => ({
       covered: entries.filter((entry) => entry.requested && (entry.retrieved > 0 || entry.retrieveConfirmed === true) && !entry.errored && !entry.neverModeled && entry.pending !== true),
       partial: entries.filter((entry) => entry.requested && (entry.retrieved === 0 && entry.retrieveConfirmed !== true || entry.errored) && !entry.neverModeled && entry.pending !== true),
@@ -34245,6 +35421,7 @@ var init_coverage_report = __esm({
       const missingCoverage = summary.missingCoverage;
       const staged = ctx.manifest.staged;
       const topUncoveredFamilies = rankUncoveredFamilies(ctx.manifest).slice(0, TOP_UNCOVERED_FAMILIES_CAP);
+      const assignmentData = await buildAssignmentDataCoverage(ctx);
       return ok({
         data: {
           coverageKnown: summary.coverageKnown,
@@ -34253,6 +35430,7 @@ var init_coverage_report = __esm({
           ...staged !== void 0 ? { stagedBuild: { tier: staged.tier, totalTiers: staged.totalTiers } } : {},
           summary,
           topUncoveredFamilies,
+          assignmentData,
           trust: {
             provenance: "offline_snapshot",
             confidence: summary.coverageKnown ? "declared" : "unknown",
@@ -49239,7 +50417,7 @@ import { existsSync as existsSync5 } from "node:fs";
 import { stat as stat6 } from "node:fs/promises";
 import { join as join20 } from "node:path";
 import { z as z81 } from "zod";
-var STALE_AGE_DAYS, MS_PER_DAY2, SKIPPED_FILES_DEGRADED_THRESHOLD, healthCheckInputSchema, buildFreshness, probeGraph, probeSourceHash, probeRenderComplete, healthCheckHandler;
+var STALE_AGE_DAYS, MS_PER_DAY2, SKIPPED_FILES_DEGRADED_THRESHOLD, STALE_FACTS_ADVISORY_DAYS, healthCheckInputSchema, buildFreshness, probeGraph, probeSourceHash, probeRenderComplete, healthCheckHandler;
 var init_health_check = __esm({
   "../mcp/dist/src/tools/health-check.js"() {
     "use strict";
@@ -49247,9 +50425,11 @@ var init_health_check = __esm({
     init_src2();
     init_src3();
     init_history_store();
+    init_coverage_report();
     STALE_AGE_DAYS = 7;
     MS_PER_DAY2 = 24 * 60 * 60 * 1e3;
     SKIPPED_FILES_DEGRADED_THRESHOLD = 100;
+    STALE_FACTS_ADVISORY_DAYS = 30;
     healthCheckInputSchema = z81.object({});
     buildFreshness = (ctx, now, sourceHashMatches, recent, update) => {
       const refreshedAt = ctx.manifest.refreshedAt;
@@ -49398,6 +50578,16 @@ var init_health_check = __esm({
       }
       const freshness = buildFreshness(ctx, now, hashProbe.match, recent, update);
       const vaultHistoryEnabled = existsSync5(join20(ctx.vaultRoot, ".git"));
+      const assignmentBase = await buildAssignmentDataCoverage(ctx);
+      let assignmentAdvisory = null;
+      if (assignmentBase.factsCounts.present && assignmentBase.factsCounts.capturedAt !== null) {
+        const capturedMs = Date.parse(assignmentBase.factsCounts.capturedAt);
+        const factsAgeDays = Number.isNaN(capturedMs) ? null : Math.max(0, Math.floor((now - capturedMs) / MS_PER_DAY2));
+        if (factsAgeDays !== null && factsAgeDays >= STALE_FACTS_ADVISORY_DAYS) {
+          assignmentAdvisory = `Assignment-data counts snapshot is ${factsAgeDays} days old (captured ${assignmentBase.factsCounts.capturedAt}); holder counts quoted from it may be stale \u2014 re-run \`sfi refresh --with-data-shape\`, or use the live tools for current rosters.`;
+        }
+      }
+      const assignmentData = { ...assignmentBase, advisory: assignmentAdvisory };
       return ok({
         data: {
           status,
@@ -49405,6 +50595,7 @@ var init_health_check = __esm({
           checks,
           coverage,
           freshness,
+          assignmentData,
           vaultHistory: {
             enabled: vaultHistoryEnabled,
             enableHint: vaultHistoryEnabled ? null : "Run `sfi vault git enable` once for `sfi.component_history` / `sfi.component_as_of`."
@@ -52722,23 +53913,6 @@ var init_naming_convention_report = __esm({
   }
 });
 
-// ../mcp/dist/src/tools/vault-assignment-disclosure.js
-var USER_ASSIGNMENT_NOT_IN_VAULT, PERMSET_INTERSECTION_NOT_AVAILABLE, SHARING_USER_ENUMERATION_NOT_AVAILABLE, userAssignmentUnavailable;
-var init_vault_assignment_disclosure = __esm({
-  "../mcp/dist/src/tools/vault-assignment-disclosure.js"() {
-    "use strict";
-    init_src3();
-    USER_ASSIGNMENT_NOT_IN_VAULT = "User and PermissionSetAssignment data are not retrieved into this vault \u2014 which users hold a profile, permission set, or group membership cannot be answered offline. Run the live org plane (read-only) or refresh with a PermissionSetAssignment facts capture for user-assignment questions.";
-    PERMSET_INTERSECTION_NOT_AVAILABLE = "Which users have multiple permission sets assigned requires PermissionSetAssignment rows (user assignment data not in vault). This tool can list each permission set structurally but cannot name users with both assignments without querying live assignment data.";
-    SHARING_USER_ENUMERATION_NOT_AVAILABLE = "Sharing rules name group/role targets, but User records and group membership to individual users are not fully available offline \u2014 cannot enumerate every user who effectively receives Edit from a group-based sharing rule without live User / GroupMember / PermissionSetAssignment data.";
-    userAssignmentUnavailable = (ctx) => {
-      const userCov = summarizeCoverage(ctx.manifest, ["User"]);
-      const psaCov = summarizeCoverage(ctx.manifest, ["PermissionSetAssignment"]);
-      return userCov.status !== "complete" || psaCov.status !== "complete";
-    };
-  }
-});
-
 // ../mcp/dist/src/tools/object-access-audit.js
 import { z as z100 } from "zod";
 var CUSTOM_OBJECT_PREFIX7, PERMISSION_SET_PREFIX2, GRANTOR_TYPES2, objectAccessAuditInputSchema, flag, compareGrants2, objectAccessAuditHandler;
@@ -55261,7 +56435,7 @@ var init_retrieve_blindspot_report = __esm({
 });
 
 // ../mcp/dist/src/context-resolution.js
-var PRONOUN_ANCHORS, REPARAM_ANCHORS, detectPronounAnchor, detectReparamAnchor, ANAPHOR_ONLY, isAnaphorOnly, ORDINAL_INDEX, SELECTION_SHAPE, NON_DESCRIPTOR_TOKENS, detectClarificationSelection, COMPONENT_ID_SHAPE, validatePreviousContext, CONTINUATION_TOOL_TYPES, continuationToolCompatible, REPARAM_FILLER, extractReparamTarget;
+var PRONOUN_ANCHORS, REPARAM_ANCHORS, detectPronounAnchor, detectReparamAnchor, ANAPHOR_ONLY, isAnaphorOnly, ORDINAL_INDEX, SELECTION_SHAPE, NON_DESCRIPTOR_TOKENS, detectClarificationSelection, RUNTIME_FOLLOW_UP_SHAPES, GAP_FOLLOW_UP_SHAPES, detectGapShapedFollowUp, COMPONENT_ID_SHAPE, validatePreviousContext, CONTINUATION_TOOL_TYPES, continuationToolCompatible, REPARAM_FILLER, extractReparamTarget;
 var init_context_resolution = __esm({
   "../mcp/dist/src/context-resolution.js"() {
     "use strict";
@@ -55352,6 +56526,78 @@ var init_context_resolution = __esm({
       const containing = options.filter((option) => option.toLowerCase().includes(token));
       return containing.length === 1 ? { kind: "selected", anaphor, selection: containing[0] } : { kind: "re-ask", anaphor };
     };
+    RUNTIME_FOLLOW_UP_SHAPES = [
+      // login history + IPs (per-user session telemetry, never modeled).
+      /\b(?:login|log[-\s]?in|sign[-\s]?in)\s+history\b|\bwho\s+(?:actually\s+)?logged\s+in\b|\bfrom\s+what\s+ip\b|\bip\s+address(?:es)?\b/i,
+      // API call logs / latency / error rate (runtime, not metadata).
+      /\bapi\s+call\s+(?:logs?|counts?|volume)\b|\b(?:error|failure)\s+rate\b|\bhow\s+(?:many\s+times|often)\s+(?:was\s+it|has\s+it\s+been)\s+called\b|\bcall\s+volume\b/i,
+      // approval-instance history — "who actually approved" (a runtime instance,
+      // not the approval-process metadata). "who CAN approve" stays a config read.
+      /\bwho\s+(?:actually\s+)?approved\b|\bapproval\s+history\b|\bwas\s+(?:it|that|this)\s+approved\b/i,
+      // record field-history — every value change ON A RECORD (runtime audit
+      // trail). "why did the FIELD change" (metadata provenance) is NOT this: the
+      // anchor is a record/instance ("on that record", "for that account").
+      /\b(?:every|all\s+the|each)\s+(?:value\s+)?changes?\s+(?:on|to|for)\s+(?:that|this|the)\s+(?:record|row|account|contact|case|lead|opportunity)\b|\bfield\s+history\s+(?:on|for)\b/i,
+      // report/dashboard subscription recipients (runtime subscriptions).
+      /\bwho\s+(?:is\s+)?subscribed\b|\bsubscription\s+recipients?\b|\bwho\s+gets?\s+(?:the|that)\s+(?:report|dashboard)\s+(?:emailed|sent)\b/i,
+      // chatter / feed posts (runtime social data).
+      /\bchatter\s+(?:posts?|activity|feed)\b|\bfeed\s+(?:posts?|items?|comments?)\b/i,
+      // sandbox refresh date / deployment logs (runtime org lifecycle telemetry).
+      /\bsandbox\s+(?:last\s+)?refresh(?:ed)?\b|\bwhen\s+was\s+(?:the\s+)?sandbox\b|\bdeployment\s+(?:logs?|history)\b|\blast\s+deploy(?:ment|ed)\b/i,
+      // flow-interview history / event publish counts (runtime execution traces).
+      /\bflow\s+interview(?:s|\s+history)?\b|\b(?:how\s+many\s+)?(?:events?\s+)?(?:were\s+)?published\b|\bpublish\s+counts?\b/i
+    ];
+    GAP_FOLLOW_UP_SHAPES = [
+      // Normative/judgment asks — the product reads metadata, it has no opinion
+      // (q891/q30 "should they be able to?", q95 "is it normal?", q1075 "was any
+      // of it risky?", q1054 "are those considered sensitive?", q1065 "how hard
+      // is it to close?", q1060 "does that mean something's broken?", q1012 "is
+      // it doing its job?").
+      [/\bshould\s+(?:they|he|she|it)\s+(?:be\s+able|have|see)\b/i, "judgment"],
+      [/\bis\s+(?:it|that|this)\s+normal\b|\bseems?\s+like\s+a\s+lot\b/i, "judgment"],
+      [/\bwas\s+(?:any\s+of\s+)?(?:it|that|this)\s+risky\b/i, "judgment"],
+      [/\bare\s+(?:those|these|they)\s+considered\s+\w+/i, "judgment"],
+      [/\bhow\s+hard\s+(?:is|would)\s+it\b/i, "judgment"],
+      [/\bdoes\s+that\s+mean\s+something(?:'s|\s+is)\s+broken\b/i, "judgment"],
+      [/\bis\s+it\s+doing\s+its\s+job\b/i, "judgment"],
+      // R4 additions — more normative/opinion shapes the 2K context run showed
+      // inheriting the prior tool: "is that a problem?", "is that too many/too
+      // much?", "is that a good idea?", "should I be worried?", "is that
+      // secure/safe?" (a verdict, not a metadata read — "is it SAFE TO DELETE"
+      // is excluded: it carries its own real route and never reaches this
+      // detector, which only runs while STILL unrouted).
+      [/\bis\s+(?:that|this|it)\s+(?:a\s+)?problem\b|\bis\s+(?:that|this|it)\s+(?:too\s+(?:many|much|few)|a\s+lot)\b/i, "judgment"],
+      [/\bis\s+(?:that|this|it)\s+(?:a\s+)?good\s+idea\b|\bshould\s+i\s+be\s+(?:worried|concerned)\b/i, "judgment"],
+      [/\bis\s+(?:that|this|it)\s+(?:considered\s+)?(?:secure|safe|risky|dangerous)\b(?!\s+to\s+delete\b)/i, "judgment"],
+      // Delivery/export asks (q914 "as a file rather than on screen", q882 "can
+      // it be exported…", q1939 "flag those as an audit finding").
+      [/\bas\s+a\s+file\b|\bcan\s+(?:it|this|that)\s+be\s+exported\b/i, "delivery"],
+      [/^\s*flag\s+(?:those|these|them|it)\b/i, "delivery"],
+      // R4 additions — more delivery/notification shapes: "email me that", "send
+      // it to …", "put it in a spreadsheet / csv / pdf", "download it".
+      [/^\s*(?:email|send|forward)\s+(?:me\s+)?(?:that|this|it|those|these|them)\b/i, "delivery"],
+      [/\b(?:as|in|to)\s+(?:a\s+)?(?:spreadsheet|csv|pdf|excel|report\s+file)\b|\b(?:can\s+(?:you|i)\s+)?download\s+(?:it|that|this|them)\b/i, "delivery"],
+      // Self-capability probes about the TOOL, not the org (q849 "does the tool
+      // trace transitive access like that, or is that beyond it?").
+      [/\b(?:does|can)\s+(?:the|this)\s+tool\b/i, "tool-self-capability"],
+      // R4 additions — "is that beyond you / can you even do that / do you have
+      // that data" self-capability probes.
+      [/\bis\s+(?:that|this)\s+beyond\s+(?:you|it|the\s+tool)\b|\bcan\s+you\s+even\b|\bdo\s+you\s+(?:have|hold)\s+(?:that|this)\s+(?:data|info(?:rmation)?)\b/i, "tool-self-capability"],
+      // Deployment-status telemetry (q1402 "was the change deployed or is it
+      // still pending?").
+      [/\bstill\s+pending\b|\bwas\s+(?:it|that|the\s+change)\s+deployed\b/i, "deployment-status"]
+    ];
+    detectGapShapedFollowUp = (question) => {
+      for (const [shape, family] of GAP_FOLLOW_UP_SHAPES) {
+        if (shape.test(question))
+          return family;
+      }
+      for (const shape of RUNTIME_FOLLOW_UP_SHAPES) {
+        if (shape.test(question))
+          return "runtime-analytics";
+      }
+      return null;
+    };
     COMPONENT_ID_SHAPE = /^[A-Za-z]+:.+$/;
     validatePreviousContext = (previous, isRegisteredTool) => {
       const ignored = [];
@@ -55437,16 +56683,56 @@ var init_context_resolution = __esm({
 });
 
 // ../mcp/dist/src/refusal-gates.js
-var INJECTION_PATTERNS, EXFIL_VERB, EXFIL_QUANTIFIER, EXFIL_SENSITIVE, EXFIL_VALUES, EXFIL_SINGLE_VALUE, INJECTION_DISCLOSURE, WRITE_VERB, WRITE_VERB_FILLER, WRITE_EXCLUDER, WRITE_SENTENCE_INITIAL, WRITE_LEAD_IN, WRITE_TRAILING_FRAME, WRITE_MAKE_SCHEMA, WRITE_GIVE_GRANT, WRITE_GIVE_INITIAL, WRITE_CHAINED_DUPE_DELETE, readOnlyAlternativeFor, RUNTIME_TRIGGERS, RUNTIME_WINDOW, RUNTIME_INCIDENT, runtimeDisclosure, EXTERNAL_SYSTEM, POLICY_ASK, RETENTION_POLICY_ASK, CONSENT_PROCESS_ASK, OPINION_ASK, SHOULD_WE, METADATA_NOUN, DELIVERY_ASK, WRITE_CODE_ASK, outOfScopeDisclosure, detectRefusalShape;
+var INJECTION_PATTERNS, EXFIL_VERB, EXFIL_QUANTIFIER, EXFIL_SENSITIVE, EXFIL_VALUES, EXFIL_SINGLE_VALUE, INJECTION_DISCLOSURE, WRITE_VERB, WRITE_VERB_FILLER, WRITE_EXCLUDER, WRITE_DOC_NOUN, WRITE_READ_FRAME, SIMULATION_TAIL, CLAUSE_SEP, WRITE_SENTENCE_INITIAL, WRITE_LEAD_IN, WRITE_TRAILING_FRAME, WRITE_MAKE_SCHEMA, WRITE_GIVE_GRANT, WRITE_GIVE_INITIAL, WRITE_CHECK_IN, WRITE_CHAINED_DEPLOY, WRITE_CHAINED_DUPE_DELETE, RUN_VERB, RUN_TARGET, RUN_GAP, RUN_IMPERATIVE_INITIAL, RUN_IMPERATIVE_LEAD_IN, RUN_ANAPHOR, runReadOnlyAlternativeFor, readOnlyAlternativeFor, IDENTITY_IDIOM, IDENTITY_ALLOWED_MUTATE, IDENTITY_LOOK_EXCLUDER, IDENTITY_DISCLOSURE, FORECAST_VERB, FORECAST_TREND, FORECAST_HORIZON, FORECAST_OUTCOME, FORECAST_STRONG_OUTCOME, FORECAST_DISCLOSURE, PROVENANCE_CREATE, PROVENANCE_CREATE_DATE, PROVENANCE_LASTMOD_ONLY, PROVENANCE_DISCLOSURE, RUNTIME_TRIGGERS, RUNTIME_WINDOW, RUNTIME_INCIDENT, runtimeDisclosure, EXTERNAL_SYSTEM, POLICY_ASK, RETENTION_POLICY_ASK, CONSENT_PROCESS_ASK, OPINION_ASK, SHOULD_WE, METADATA_NOUN, DELIVERY_ASK, WRITE_CODE_ASK, DRAFT_DOCUMENT_ASK, CAREER_ASK, outOfScopeDisclosure, detectRefusalShape;
 var init_refusal_gates = __esm({
   "../mcp/dist/src/refusal-gates.js"() {
     "use strict";
     INJECTION_PATTERNS = [
-      /\bignore\s+(?:your|all|the)\s+(?:previous|prior|read-?only)\s+(?:instructions?|rules?|restrictions?)\b/i,
+      // "ignore your previous/prior/read-only instructions|rules|restrictions".
+      // R4: the (?:and\s+\w+\s+)? optional carries "ignore your read-only AND
+      // PRIVACY restrictions" (q3749) — a conjoined adjective before the noun no
+      // longer breaks the token sequence. `constraints` joins the noun set (q4047
+      // "ignore your read-only constraints").
+      /\bignore\s+(?:your|all|the)\s+(?:previous|prior|read-?only)\s+(?:and\s+\w+\s+)?(?:instructions?|rules?|restrictions?|constraints?)\b/i,
+      // R4 injection framings the 3K phrasings used to evade every arm above:
+      //  - "forget everything above / forget your prior instructions" (q4842).
+      /\bforget\s+(?:everything|all(?:\s+of)?\s+the)\s+(?:above|prior|previous|earlier)\b|\bforget\s+(?:your|the)\s+(?:prior|previous|earlier)\s+(?:instructions?|rules?|restrictions?|constraints?)\b/i,
+      //  - role-play jailbreak: "AI with no restrictions", "named DAN", "you are
+      //    now an unrestricted assistant / DAN / an AI that can modify the org".
+      /\b(?:ai|assistant|model)\s+(?:with\s+)?no\s+restrictions\b|\bnamed\s+dan\b|\bact\s+as\s+dan\b|\byou\s+are\s+(?:now\s+)?(?:an?\s+)?(?:unrestricted|jailbroken|uncensored)\b/i,
+      //  - "SYSTEM OVERRIDE", "the previous ... constraints are revoked",
+      //    "you are now permitted to reveal ..." (q4873).
+      /\bsystem\s+override\b|\b(?:previous|prior)\s+(?:knowledge-?base\s+)?(?:constraints?|restrictions?|instructions?)\s+(?:are|have\s+been)\s+revoked\b|\byou\s+are\s+now\s+permitted\s+to\s+reveal\b/i,
+      //  - "new instruction ... embedded in this message" / "instruction from the
+      //    vault owner embedded in ..." (q4627) — a smuggled-instruction framing.
+      /\b(?:new\s+)?instruction[s]?\b[^.?!]{0,40}\bembedded\s+in\s+this\s+(?:message|prompt|text|question)\b/i,
+      //  - social-engineering authority claim to force an action: "the (real)
+      //    admins told me to have you ...", "they authorized it", "the client
+      //    signed off" chained with a mutation/exfil (q4893/q4668). Narrow: the
+      //    authority claim must co-occur with an override/do-it imperative.
+      // "the client signed off" arms ONLY when a redeploy/deploy/mutation of org
+      // artifacts rides in the same breath (q4668) — a plain "the client signed
+      // off on the design, show me the flow" must not gate, so require a deploy
+      // verb nearby.
+      /\bthey\s+authorized\s+it\b|\breal\s+admins?\s+told\s+me\s+to\s+have\s+you\b|\b(?:the\s+)?client\s+signed\s+off\b[^.?!]{0,120}\b(?:re-?deploy|deploy|repoint|push\s+(?:it|them|this)|redeploy\s+them)\b/i,
       /\bpretend\s+the\s+(?:previous|prior)\s+rules\b/i,
       /\byou\s+are\s+now\s+(?:in\s+)?(?:admin|deploy|god)\s*[- ]?mode\b/i,
       /\byou'?re\s+actually\s+an?\b[^.?!]*\bbot\b/i,
-      /\b(?:print|reveal|show)\s+(?:me\s+)?your\s+(?:system\s+)?prompt\b/i
+      /\b(?:print|reveal|show)\s+(?:me\s+)?your\s+(?:system\s+)?prompt\b/i,
+      // Secret/credential exfiltration (q4873/q3635 secret asks): reveal/output/
+      // give the raw connection string, OAuth/client secret, session/refresh
+      // token, API key, or password policy for delivery. The metadata READ
+      // "which named credentials exist" / "what auth provider does X use" carries
+      // no reveal-the-SECRET-VALUE verb and stays routed. `endpoint` alone is NOT
+      // a secret (q4956 "I need the endpoint on the named credential" routes).
+      /\b(?:reveal|output|show\s+me|give\s+me|dump|print|expose)\b[^.?!]{0,60}\b(?:client\s+secret|oauth\s+secret|connection\s+string|session\s+token|refresh\s+token|api\s+key|secret\s+key|private\s+key)\b/i,
+      // Privilege-escalation asks (q1548 "sudo give me full access"): `sudo` as a
+      // command prefix, or a grant-to-SELF ("give me full/admin access"). The
+      // READ delivery ask "give me the FLS grant list" carries no privilege noun
+      // and stays routed — the escalation arm requires full/admin/elevated +
+      // access/permission.
+      /(?:^|[.!?;]\s+)sudo\b/i,
+      /\bgive\s+me\s+(?:full|admin|superuser|elevated|god[-\s]?mode)\s+(?:access|permissions?|rights?|privileges?)\b/i
     ];
     EXFIL_VERB = /\b(?:dump|export|give\s+me|tell\s+me|list|retrieve)\b/i;
     EXFIL_QUANTIFIER = /\b(?:every|all|actual|the\s+real|random)\b/i;
@@ -55454,16 +56740,45 @@ var init_refusal_gates = __esm({
     EXFIL_VALUES = /\bvalues?\b|\bstored\b/i;
     EXFIL_SINGLE_VALUE = /\b(?:what(?:'s|s|\s+is)|show\s+me|give\s+me|pull)\s+the\s+(?:ssn|social\s+security(?:\s+number)?)\b(?!\s+fields?\b)[^.?!]{0,60}\b(?:lead|contact|record|student|person|user|account|applicant)s?\b/i;
     INJECTION_DISCLOSURE = "REFUSED: this request asks me to override instructions or exfiltrate record values. sf-intelligence reads metadata only; it never returns stored record values and its instructions are not overridable.";
-    WRITE_VERB = "(?:create|add|delete|remove|update|change|(?<!permission\\s)set|deploy|assign|reassign|revoke|deactivate|activate|disable|enable|merge|reset|rename|fix|grant|provision|turn\\s+(?:on|off)|clean\\s+up|migrate|convert|insert|upsert|push|publish|install|uninstall|schedule|upgrade|downgrade|throttle|purge)";
-    WRITE_VERB_FILLER = "(?:(?:bulk|mass|batch|just|please|go\\s+ahead\\s+and)\\s+)*";
-    WRITE_EXCLUDER = /\b(?:am\s+i|can\s+i|could\s+i|do\s+i|who\s+can|who\s+is\s+able|allowed\s+to|able\s+to|what\s+if|what\s+would|would\s+happen|is\s+it\s+safe|safe\s+to|before\s+i|if\s+i|should\s+i|how\s+do\s+i|how\s+would\s+i|what\s+happens\s+when)\b/i;
-    WRITE_SENTENCE_INITIAL = new RegExp(`(?:^|[.!?;]\\s+)(?:please\\s+|just\\s+)?${WRITE_VERB_FILLER}(${WRITE_VERB}\\b[^.?!;]{0,80})`, "i");
-    WRITE_LEAD_IN = new RegExp(`\\b(?:please|just|go\\s+ahead\\s+and|can\\s+(?:you|u)|could\\s+(?:you|u)|would\\s+(?:you|u)|you\\s+should|i\\s+need\\s+you\\s+to)\\s+(?:please\\s+|just\\s+)?${WRITE_VERB_FILLER}(${WRITE_VERB}\\b[^.?!;]{0,80})`, "i");
+    WRITE_VERB = "(?:create|add|delete|remove|update|change|(?<!permission\\s)set|(?:quick[-\\s]?|re)?deploy|assign|reassign|revoke|deactivate|activate|disable|enable|merge|reset|rename|fix|grant|provision|turn\\s+(?:on|off)|clean\\s+up|migrate|convert|insert|upsert|push|publish|install|uninstall|schedule|upgrade|downgrade|throttle|purge|build|split|rotate|bump|pin|operationalize|repoint|stand\\s+up|spin\\s+up|comment\\s+out|wire\\s+(?:it|them|this|that)?\\s*(?:in|into)|roll\\s+(?:it|them|this|that)?\\s*into)";
+    WRITE_VERB_FILLER = "(?:(?:bulk|mass|batch|just|please|go\\s+ahead\\s+and)[-\\s]+)*";
+    WRITE_EXCLUDER = /\b(?:am\s+i|can\s+i|could\s+i|do\s+i|who\s+can|who\s+is\s+able|allowed\s+to|able\s+to|what\s+if|what\s+would|would\s+happen|is\s+it\s+safe|safe\s+to|before\s+i|if\s+(?:i|we)|when\s+(?:i|we)|suppose|should\s+i|how\s+do\s+i|how\s+would\s+i|what\s+happens\s+when)\b|\bsafely\s*\?|\bwhat\s+(?:depends\s+on|breaks|would\s+break|will\s+break|stops\s+working)\b/i;
+    WRITE_DOC_NOUN = "(?:onboarding|admin|developer|dev|architecture|data)?[-\\s]?(?:doc(?:ument(?:ation)?|s)?|handbook|tour|walkthrough|overview|dictionary|summary|guide|primer|runbook|onboarding|write[-\\s]?up|report\\s+of)";
+    WRITE_READ_FRAME = new RegExp(
+      // 1 — doc-generation: a build/create/generate/write/draft/make verb whose
+      // object (within a short window) is a documentation noun.
+      `\\b(?:build|create|generate|write|draft|put\\s+together|make|need|want|give\\s+me)\\b[^.?!;]{0,40}\\b${WRITE_DOC_NOUN}\\b|\\b${WRITE_DOC_NOUN}\\b[^.?!;]{0,30}\\.?\\s*(?:build|create|generate|make|put\\s+together)\\s+(?:it|this|that|one)\\b|\\b(?:which|what|who|whose|list\\s+(?:the\\s+)?)\\b[^.?!;]{0,40}\\b(?:enables?|disables?|grants?)\\b|\\b(?:before|after|ahead\\s+of|prior\\s+to|until|once)\\s+(?:a\\s+|the\\s+|we\\s+|you\\s+|i\\s+)?(?:re-?)?deploy(?:ment|ing)?\\b`,
+      "i"
+    );
+    SIMULATION_TAIL = /\b(?:and\s+)?(?:tell|show|give)\s+me\s+(?:the\s+)?(?:impact|blast\s+radius|consequences?|every\s+conflict|conflicts|what\s+(?:breaks|happens|stops|changes))\b|[—–-]\s*(?:impact|consequences?|blast\s+radius)\s*\??\s*$|\b(?:impact|consequences)\s*\?\s*$|\bwhat(?:'s|\s+is)\s+the\s+(?:impact|blast\s+radius|fallout)\b|\bwhat\s+(?:happens|stops|breaks)\s+(?:to|if|when|after|downstream)\b/i;
+    CLAUSE_SEP = "(?:^|[.!?;]\\s+|\\s+[\u2014\u2013]\\s*)";
+    WRITE_SENTENCE_INITIAL = new RegExp(`${CLAUSE_SEP}(?:please\\s+|just\\s+)?${WRITE_VERB_FILLER}(${WRITE_VERB}\\b[^.?!;]{0,80})`, "i");
+    WRITE_LEAD_IN = new RegExp(`\\b(?:please|(?<!\\b(?:or|vs|than)\\s)just|go\\s+ahead\\s+and|can\\s+(?:you|u)|could\\s+(?:you|u)|would\\s+(?:you|u)|you\\s+should|i\\s+(?:need|want)\\s+you\\s+to)\\s+(?:please\\s+|just\\s+)?${WRITE_VERB_FILLER}(${WRITE_VERB}\\b[^.?!;]{0,80})`, "i");
     WRITE_TRAILING_FRAME = new RegExp(`\\b(${WRITE_VERB}\\b[^.?!;]{0,80}?\\b(?:for\\s+me|right\\s+now|and\\s+confirm)\\b[^.?!;]{0,20})`, "i");
     WRITE_MAKE_SCHEMA = new RegExp(`\\b(?:can|could|would)\\s+(?:you|u)\\b[^.?!;]{0,10}\\s(make\\b[^.?!;]{0,60}\\b(?:required|mandatory|optional|unique|read[-\\s]?only|editable|visible)\\b)`, "i");
     WRITE_GIVE_GRANT = new RegExp(`\\b(?:can|could|would)\\s+(?:you|u)\\b[^.?!;]{0,30}\\b(give\\s+(?!me\\b)[^.?!;]{0,60}\\b(?:profile|permission|perm\\s+set|access|user)\\b[^.?!;]{0,40})`, "i");
     WRITE_GIVE_INITIAL = /(?:^|[.!?;]\s+)(give\s+(?!me\b)[^.?!;]{0,60}\b(?:admin|access|permission|profile)\b[^.?!;]{0,30})/i;
-    WRITE_CHAINED_DUPE_DELETE = /\b(?:and|then)\s+(?:just\s+)?((?:delete|remove|purge|merge)\s+(?:the\s+)?dup(?:e|licate)s?\b[^.?!;]{0,30})/i;
+    WRITE_CHECK_IN = /\b(check\s+(?:it|them|this|that)\s+in|commit\s+(?:it|them|this|the\s+\w+)|push\s+(?:it|them|this)\s+to\s+(?:prod|production|the\s+repo)|promote\s+(?:it|them|this)\s+to\s+(?:prod|production))\b/i;
+    WRITE_CHAINED_DEPLOY = /(?:^|[.!?;]\s+|,\s*(?:and\s+|then\s+)?|\band\s+|\bthen\s+)((?:re-?deploy|quick[-\s]?deploy|repoint)\b[^.?!;]{0,60})/i;
+    WRITE_CHAINED_DUPE_DELETE = /(?:\b(?:and|then)\s+(?:just\s+)?|(?:^|[.!?;]\s+)(?:just\s+)?)((?:delete|remove|purge|merge)\s+(?:all\s+|the\s+|every\s+){0,2}dup(?:e|licate)s?\b[^.?!;]{0,30})/i;
+    RUN_VERB = "(?:run|re-?run|execute|invoke|kick\\s+off|trigger|launch|fire\\s+off)";
+    RUN_TARGET = "(?:flows?|triggers?|batch(?:\\s+(?:jobs?|class(?:es)?|apex))?|jobs?|apex\\s+class(?:es)?|automations?|scripts?)";
+    RUN_GAP = "(?:(?!\\b(?:on|of|for|across|against|in|over|about)\\b)[^.?!;]){0,60}?";
+    RUN_IMPERATIVE_INITIAL = new RegExp(`(?:^|[.!?;]\\s+)(?:please\\s+|just\\s+)?(${RUN_VERB}\\b${RUN_GAP}\\b${RUN_TARGET}\\b[^.?!;]{0,60})`, "i");
+    RUN_IMPERATIVE_LEAD_IN = new RegExp(`\\b(?:please|just|go\\s+ahead\\s+and|can\\s+(?:you|u)|could\\s+(?:you|u)|would\\s+(?:you|u)|you\\s+should|i\\s+need\\s+you\\s+to)\\s+(?:please\\s+|just\\s+)?(${RUN_VERB}\\b${RUN_GAP}\\b${RUN_TARGET}\\b[^.?!;]{0,60})`, "i");
+    RUN_ANAPHOR = new RegExp(`(?:(?:^|[.!?;]\\s+)(?:please\\s+|just\\s+)?|\\b(?:please|just|go\\s+ahead\\s+and|can\\s+(?:you|u)|could\\s+(?:you|u)|would\\s+(?:you|u)|you\\s+should|i\\s+need\\s+you\\s+to)\\s+(?:please\\s+|just\\s+)?)(${RUN_VERB}\\s+(?:it|that|this)\\b(?!\\s+(?:by|past)\\b)[^.?!;]{0,40}|(?:kick|fire|set)\\s+(?:it|that|this)\\s+off\\b[^.?!;]{0,30})`, "i");
+    runReadOnlyAlternativeFor = (verbPhrase) => {
+      const v2 = verbPhrase.toLowerCase();
+      if (/\bflows?\b/.test(v2))
+        return "sfi.explain_flow";
+      if (/\b(?:batch|jobs?)\b/.test(v2))
+        return "sfi.scheduled_job_catalog";
+      if (/\btriggers?\b/.test(v2))
+        return "sfi.what_happens_on_save";
+      if (/\bapex|class(?:es)?\b/.test(v2))
+        return "sfi.explain_apex_method";
+      return "sfi.get_impact";
+    };
     readOnlyAlternativeFor = (verbPhrase, question) => {
       const v2 = verbPhrase.toLowerCase();
       const q2 = question.toLowerCase();
@@ -55499,14 +56814,153 @@ var init_refusal_gates = __esm({
       }
       return "sfi.get_impact";
     };
+    IDENTITY_IDIOM = /\bcan\s+i\s+be\s+trusted\s+to\b|\bwithin\s+my\s+power\b|\babove\s+my\s+(?:permission\s+level|pay\s+grade)\b|\bwhat\s+(?:am\s+i|i'?m)\s+capable\s+of\b|\bwondering\s+what\s+i'?m\s+capable\s+of\b/i;
+    IDENTITY_ALLOWED_MUTATE = /\bam\s+i\s+(?:allowed|permitted|able)\s+to\s+(?:change|delete|remove|merge|deactivate|disable|create|rename|reset|convert|reassign|modify|update)\b|\bis\s+it\s+(?:okay?|ok)\s+for\s+me\s+to\s+(?:change|delete|remove|merge|deactivate|disable|create|rename|reset|convert|reassign|modify|update)\b/i;
+    IDENTITY_LOOK_EXCLUDER = /\bam\s+i\s+(?:allowed|permitted|able)\s+to\s+(?:look|see|view|read|ask|know|check|understand|open)\b|\bis\s+it\s+(?:okay?|ok)\s+for\s+me\s+to\s+(?:look|see|view|read|ask|know|check)\b/i;
+    IDENTITY_DISCLOSURE = "HONEST GAP (identity): sf-intelligence has no session-user identity \u2014 it cannot know what YOU specifically are allowed to do. Name the user, profile, or permission set to check and I can answer from the permission metadata (sfi.effective_permissions / sfi.user_ability). Which user or profile should I check?";
+    FORECAST_VERB = /\b(?:forecast|predict|projection|projecting|extrapolate|estimate\s+how\s+many|best\s+estimate\s+of\s+how\s+many)\b|\bproject\s+(?:our|the|how|where|when|my)\b|\bwhen\s+do\s+you\s+project\b|\bgive\s+me\s+your\s+(?:projection|best\s+estimate|churn\s+forecast)\b/i;
+    FORECAST_TREND = /\b(?:current\s+(?:\w+\s+)?(?:growth|trend|trajectory)|given\s+(?:current|projected)\s+(?:\w+\s+)?(?:growth|trends?)|based\s+on\s+(?:current\s+)?trends?|at\s+the\s+current\s+(?:growth\s+)?rate|projected\s+growth)\b/i;
+    FORECAST_HORIZON = /\b(?:next\s+(?:quarter|term|month|fiscal\s+year|year)|by\s+(?:the\s+)?end\s+of\s+next\b|in\s+(?:12\s+months|two\s+quarters|\d+\s+(?:months|quarters|years))|next\s+term)\b/i;
+    FORECAST_OUTCOME = /\bwill\s+(?:we|it|this|our|migrating|rolling|the)\b|\b(?:hit|exceed|run\s+out|breach|reach)\b|\bhow\s+many\b|\bhow\s+likely\b|\bwe'?ll\b|\bwhere\s+will\b/i;
+    FORECAST_STRONG_OUTCOME = /\bwill\b[^.?!]{0,60}\b(?:hit|exceed|run\s+out|breach|reach)\b/i;
+    FORECAST_DISCLOSURE = "HONEST GAP (forecast): sf-intelligence has no time-series or forecasting model \u2014 it reads the CURRENT metadata/limits snapshot, not future projections or growth trends. I can show you the present state (e.g. sfi.live_org_limits, sfi.org_pulse, sfi.tech_debt_score) so you can extrapolate, but the prediction itself is out of scope.";
+    PROVENANCE_CREATE = /\bwho\s+(?:originally\s+)?(?:created|built|authored|made|wrote|set\s+up|first\s+(?:created|built|granted|authored))\b|\b(?:original|initial)\s+author\b|\bwho\s+first\s+(?:created|built|authored)\b|\bcreator\s+of\b|\bwho\s+(?:created|built|authored|set\s+up)\s+(?:it|this|that|the)\b/i;
+    PROVENANCE_CREATE_DATE = /\bcreation\s+date\b|\binstall\s+date\b/i;
+    PROVENANCE_LASTMOD_ONLY = /\bwho\s+(?:last\s+(?:modified|changed|updated|edited)|modified|changed|updated|edited)\b/i;
+    PROVENANCE_DISCLOSURE = "HONEST GAP (authorship): the vault records LastModified (who/when) where the refresh captured it, but never CreatedBy / original author / creation date \u2014 Salesforce does not expose creator provenance in metadata source. For the answerable side, sfi.last_modified reports who LAST changed a component and when.";
     RUNTIME_TRIGGERS = [
       [/\blogin\s+history\b|\baudit\s+trail\s+of\s+logins?\b/i, "login history"],
+      // Per-user LOGIN EVENTS (hon-031/hon-036/hon-060): who logged in when,
+      // exact login timestamps, who is logged in right now, or a full per-user
+      // last-login roster. All are LoginHistory/session event data no tool reads.
+      // Precision guards, each a live_inactive_users question that must NOT gate:
+      // "which users are inactive", "who HASN'T logged in for 90 days" (the
+      // negation breaks the strict token sequence), "login IP ranges on a
+      // profile" (profile_security metadata — no logged-in/timestamp token).
+      [
+        /\b(?:which|what)\s+(?:specific\s+)?users?\s+(?:have\s+|are\s+)?logged\s+in(?:to)?\b|\bwho\s+logged\s+in(?:to)?\b/i,
+        "per-user login events (who logged in when)"
+      ],
+      [
+        /\blogin\s+timestamps?\b|\bcurrently\s+logged\s+in(?:to)?\b|\blogged\s+in(?:to)?\b[^.?!]{0,30}\bright\s+now\b/i,
+        "login sessions/timestamps"
+      ],
+      [
+        /\b(?:every|each|all)\s+(?:salesforce\s+)?users?'?s?\b[^.?!]{0,30}\blast\s+login\b/i,
+        "a full per-user last-login roster (sfi.live_inactive_users covers dormancy thresholds, not a full roster)"
+      ],
       [/\badoption\b|\bhow\s+often\s+do\s+users\s+actually\s+use\b/i, "adoption/usage telemetry"],
       [
         /\bping\s+(?:the\s+)?\S+|\bendpoints?\b[^.?!]*\bup\b|\b(?:returned|returning|throwing|threw)\s+errors?\b/i,
         "endpoint health"
       ],
-      [/\brunning[-\s]user\s+context\b/i, "the runtime running-user context"]
+      [/\brunning[-\s]user\s+context\b/i, "the runtime running-user context"],
+      // Automation EXECUTION forensics (hon-032/hon-039/hon-037): traces of what
+      // a run touched, aggregate run counts, the error message from the last
+      // failure. Static reads stay routed: "how many times is this field
+      // REFERENCED" (no run verb), "what runs when an Application is submitted"
+      // (no how-many-times/trace), "when was it last MODIFIED" (no failed/ran).
+      [
+        /\bexecution\s+trace\b|\bwhat\s+records\s+did\s+(?:it|the\s+\S+(?:\s+\S+)?)\s+touch\b/i,
+        "flow/automation execution traces"
+      ],
+      [
+        /\bhow\s+many\s+times\s+(?:has|have|did|was|were)\b[^.?!]{0,80}\b(?:executed|run|ran|fired|triggered)\b/i,
+        "aggregate automation run counts (sfi.live_automation_fired infers per-record only)"
+      ],
+      [
+        /\b(?:the\s+)?last\s+time\b[^.?!]{0,60}\b(?:failed|errored|crashed|ran)\b/i,
+        "run/failure forensics from past executions"
+      ],
+      // Apex/query RUNTIME PROFILING + debug logs (hon-040/hon-044/hon-053):
+      // CPU/heap profiles of a past run, debug logs, SOQL execution plans.
+      // Static reads stay routed: "which classes RISK hitting governor limits"
+      // (governor_limit_risks — no profile/log/plan noun), "which class contains
+      // System.debug" (code-literal search — no `debug log` bigram).
+      [
+        /\b(?:cpu\s+time|heap\s+(?:usage|size)|memory\s+(?:usage|utilization|consumption))\b[^.?!]{0,50}\bprofile\b|\bprofile\b[^.?!]{0,50}\b(?:cpu\s+time|heap\s+usage)\b/i,
+        "runtime CPU/heap profiling"
+      ],
+      [/\bmemory\s+(?:utilization|consumption)\b|\bapplication\s+servers?\b/i, "infrastructure telemetry"],
+      // Debug-LOG retrieval needs the retrieval-verb frame: "SHOW ME the debug
+      // log from yesterday's batch run" is runtime; "leftover debug logs in apex"
+      // (q522 — System.debug code artifacts, search_apex_source) and "is it in a
+      // debug log anywhere" carry no retrieval verb and stay routed. Shield
+      // EVENT-MONITORING logs (router-v2 R2, hon-057) are the same retrieval
+      // shape — runtime telemetry no vault holds; "which flows subscribe to
+      // platform events" carries no log noun and stays routed.
+      [
+        /\b(?:show|see|view|pull|get|give|retrieve|read|check|download|fetch)\b[^.?!]{0,45}\b(?:debug|event[\s-]monitoring)\s+logs?\b/i,
+        "debug / event-monitoring logs"
+      ],
+      [
+        /\b(?:query|execution|soql)\s+plans?\b|\bindexes?\s+(?:are\s+)?being\s+used\b/i,
+        "SOQL execution plans / index usage"
+      ],
+      // Message DELIVERY telemetry (hon-056/hon-041): delivered/bounce counts and
+      // the ACTUAL content of sent messages. Metadata reads stay routed: "which
+      // email templates are unused" (live_email_template_usage), "what emails go
+      // out for this approval" (sendsEmail edges — no delivered/sent-count ask).
+      [
+        /\b(?:emails?|sms|messages?|texts?)\b[^.?!]{0,50}\b(?:delivered|deliverability|bounced?|bounce\s+rate)\b/i,
+        "message delivery telemetry"
+      ],
+      [
+        /\bhow\s+many\s+(?:emails?|sms|messages?|texts?)\b[^.?!]{0,60}\b(?:sent|delivered|went\s+out)\b/i,
+        "sent-message counts"
+      ],
+      [
+        /\bactual\s+content\s+of\s+the\s+(?:emails?|messages?|texts?)\b/i,
+        "the content of individually sent messages (the TEMPLATE body is metadata \u2014 sfi.get_component reads it)"
+      ],
+      // Chatter/feed RUNTIME activity (q4450 "who posted last in the … chatter
+      // group"): who posted, most recent post, feed content — CollaborationGroup
+      // feed data that lives in the runtime org, never the vault. Metadata reads
+      // stay routed: "which public groups exist" / "who is IN the group"
+      // (live_group_members) carry no post/feed verb.
+      [
+        /\bwho\s+(?:posted|commented|last\s+posted)\b|\b(?:chatter|feed)\b[^.?!]{0,40}\b(?:posts?|activity|comments?)\b|\b(?:last|latest|recent)\s+(?:chatter|feed)\s+posts?\b/i,
+        "Chatter/feed activity (who posted, most recent posts)"
+      ],
+      // Site/community WEB ANALYTICS (hon-050): click paths, page views.
+      [
+        /\b(?:click|page|site|web)\s*[- ]?(?:analytics|traffic)\b|\bpage\s+views?\b|\bwhich\s+pages\b[^.?!]{0,60}\bvisit/i,
+        "site/community click analytics"
+      ],
+      // RECORD-LEVEL field history (hon-054): before/after values of changed
+      // records. "Which fields HAVE history tracking enabled" is object metadata
+      // and stays routed (no before/after-values bigram).
+      [
+        /\bbefore(?:\s*\/\s*|\s*-\s*|\s+and\s+)after\b[^.?!]{0,40}\b(?:values?|data)\b/i,
+        "record-level field history (before/after values)"
+      ],
+      // RECORD-ACCESS audit (q960/q1117): who ACCESSED/viewed a record or field.
+      // "Who CAN see/access X" is a permissions read (who_can_access_object /
+      // field_access_audit) and never matches — the arm requires the past-tense
+      // accessed/viewed/opened event verb.
+      [
+        /\bwho\b[^.?!]{0,30}\b(?:accessed|viewed|opened|looked\s+at)\b[^.?!]{0,60}\b(?:records?|fields?|data)\b/i,
+        "record-access audit events (who accessed what)"
+      ],
+      // R3 §5b AUDIT-TRAIL-PLANE arms (8-question over-route cluster): Setup
+      // Audit Trail asks — who changed a SETTING (FLS, sharing, OWD, session/
+      // password policy) and when. Component lastModifiedBy IS metadata
+      // (sfi.last_modified stays routed — those asks say "who changed <component>",
+      // no settings noun); FLS/OWD/policy flips are only in the Setup Audit
+      // Trail, which neither the vault nor the live plane reads.
+      [/\bsetup\s+audit\s+trail\b/i, "Setup Audit Trail entries"],
+      [
+        /\bwho\s+(?:modified|changed|flipped|updated|edited)\b[^.?!]{0,50}\b(?:field-?level\s+security|fls|sharing\s+settings?|org-?wide\s+defaults?|owd|session\s+settings?|password\s+polic\w*|mfa)\b/i,
+        "who changed org security settings and when (Setup Audit Trail data)"
+      ],
+      // R3 §5b: report/dashboard DEFINITIONS (source object, columns, broken
+      // references) are not retrieved into the vault — "which reports are
+      // stale/unused" (live_report_usage) and "who can see the dashboard"
+      // (folder access) carry none of these definition verbs and stay routed.
+      [
+        /\b(?:reports?|dashboards?)\b[^.?!]{0,50}\b(?:built|based)\s+on\b|\breports?\b[^.?!]{0,50}\breference\b[^.?!]{0,50}\b(?:deleted|renamed|broken|missing)\b|\bdashboards?\b[^.?!]{0,40}\b(?:broken|point\s+at)\b/i,
+        "report/dashboard definitions (source object, columns, referenced fields) \u2014 not retrieved into the vault"
+      ]
     ];
     RUNTIME_WINDOW = /\b(?:this\s+week|yesterday|last\s+night|in\s+the\s+\w+\s+incident)\b/i;
     RUNTIME_INCIDENT = /\b(?:errors?|failed|failures?|incident|outage|gated)\b/i;
@@ -55520,6 +56974,8 @@ var init_refusal_gates = __esm({
     METADATA_NOUN = /\b(?:field|object|flow|trigger|class|profile|permission|layout|validation|record\s+type|apex|report|dashboard|picklist|component|rule)\b|__(?:c|mdt|e|x|b|kav)\b/i;
     DELIVERY_ASK = /\bemail\s+me\b|\bsend\s+(?:this|it)\s+to\b|\bpost\s+(?:this\s+|it\s+)?to\s+slack\b/i;
     WRITE_CODE_ASK = /\bwrite\s+(?:me\s+)?(?:an?\s+)?(?:apex|lwc|trigger|class|component)\b[^.?!]*\b(?:that|to)\b/i;
+    DRAFT_DOCUMENT_ASK = /\bdraft\s+(?:me\s+)?(?:a|an)\b[^.?!]{0,60}\b(?:agreement|contract|clause|policy|memo|press\s+release)\b/i;
+    CAREER_ASK = /\bhow\s+do\s+i\s+become\b/i;
     outOfScopeDisclosure = (topic) => `OUT OF SCOPE: sf-intelligence answers questions about this org's Salesforce metadata. ${topic} is outside that boundary (no external systems, no policy authorship, no code generation, no message delivery).`;
     detectRefusalShape = (question) => {
       const q2 = question.replace(/[‘’ʼ]/g, "'").replace(/\s+/g, " ").trim();
@@ -55530,7 +56986,9 @@ var init_refusal_gates = __esm({
         return { kind: "injection-exfiltration", disclosure: INJECTION_DISCLOSURE };
       }
       if (!WRITE_EXCLUDER.test(q2)) {
-        const verbPhrase = (WRITE_SENTENCE_INITIAL.exec(q2) ?? WRITE_LEAD_IN.exec(q2) ?? WRITE_TRAILING_FRAME.exec(q2) ?? WRITE_MAKE_SCHEMA.exec(q2) ?? WRITE_GIVE_GRANT.exec(q2) ?? WRITE_GIVE_INITIAL.exec(q2) ?? WRITE_CHAINED_DUPE_DELETE.exec(q2))?.[1]?.trim().replace(/[,;:]$/, "");
+        const readFrame = WRITE_READ_FRAME.test(q2);
+        const simulationFrame = SIMULATION_TAIL.test(q2) || readFrame;
+        const verbPhrase = simulationFrame ? void 0 : (WRITE_SENTENCE_INITIAL.exec(q2) ?? WRITE_LEAD_IN.exec(q2) ?? WRITE_TRAILING_FRAME.exec(q2) ?? WRITE_MAKE_SCHEMA.exec(q2) ?? WRITE_GIVE_GRANT.exec(q2) ?? WRITE_GIVE_INITIAL.exec(q2) ?? WRITE_CHAINED_DUPE_DELETE.exec(q2) ?? WRITE_CHAINED_DEPLOY.exec(q2) ?? WRITE_CHECK_IN.exec(q2))?.[1]?.trim().replace(/[,;:]$/, "");
         if (verbPhrase !== void 0 && verbPhrase.length > 0) {
           const alternative = readOnlyAlternativeFor(verbPhrase, q2);
           return {
@@ -55539,13 +56997,35 @@ var init_refusal_gates = __esm({
             readOnlyAlternative: alternative
           };
         }
+        const runPhrase = (RUN_IMPERATIVE_INITIAL.exec(q2) ?? RUN_IMPERATIVE_LEAD_IN.exec(q2) ?? RUN_ANAPHOR.exec(q2))?.[1]?.trim().replace(/[,;:]$/, "");
+        if (runPhrase !== void 0 && runPhrase.length > 0) {
+          const alternative = runReadOnlyAlternativeFor(runPhrase);
+          return {
+            kind: "write-imperative",
+            disclosure: `REFUSED (read-only boundary): sf-intelligence never executes org automation \u2014 it cannot ${runPhrase}. I can show you what it WOULD do instead: ${alternative}.`,
+            readOnlyAlternative: alternative
+          };
+        }
+      }
+      if ((IDENTITY_IDIOM.test(q2) || IDENTITY_ALLOWED_MUTATE.test(q2)) && !IDENTITY_LOOK_EXCLUDER.test(q2)) {
+        return { kind: "identity-gap", disclosure: IDENTITY_DISCLOSURE };
+      }
+      if (!SIMULATION_TAIL.test(q2)) {
+        const isForecast = FORECAST_VERB.test(q2) || FORECAST_TREND.test(q2) && FORECAST_HORIZON.test(q2) && FORECAST_OUTCOME.test(q2) || FORECAST_TREND.test(q2) && FORECAST_STRONG_OUTCOME.test(q2);
+        if (isForecast) {
+          return { kind: "forecast-gap", disclosure: FORECAST_DISCLOSURE };
+        }
+      }
+      const provenanceCreate = PROVENANCE_CREATE.test(q2) || PROVENANCE_CREATE_DATE.test(q2) && /\bcreated?\b/i.test(q2);
+      if (provenanceCreate && !(PROVENANCE_LASTMOD_ONLY.test(q2) && !PROVENANCE_CREATE.test(q2))) {
+        return { kind: "provenance-gap", disclosure: PROVENANCE_DISCLOSURE };
       }
       const runtimeTopic = RUNTIME_TRIGGERS.find(([pattern]) => pattern.test(q2))?.[1] ?? (RUNTIME_WINDOW.test(q2) && RUNTIME_INCIDENT.test(q2) ? "runtime incident forensics" : void 0);
       if (runtimeTopic !== void 0) {
         return { kind: "runtime-analytics", disclosure: runtimeDisclosure(runtimeTopic) };
       }
       const externalSystem = EXTERNAL_SYSTEM.exec(q2)?.[1];
-      const outOfScopeTopic = externalSystem !== void 0 ? `"${externalSystem}"` : RETENTION_POLICY_ASK.test(q2) ? "A data-retention policy (organizational governance, not org metadata)" : CONSENT_PROCESS_ASK.test(q2) ? "A consent process (organizational governance, not org metadata)" : POLICY_ASK.test(q2) ? "Org policy authorship" : OPINION_ASK.test(q2) ? "An opinion" : DELIVERY_ASK.test(q2) ? "Message delivery" : WRITE_CODE_ASK.test(q2) ? "Code generation" : SHOULD_WE.test(q2) && !METADATA_NOUN.test(q2) ? "An org-decision recommendation" : void 0;
+      const outOfScopeTopic = externalSystem !== void 0 ? `"${externalSystem}"` : RETENTION_POLICY_ASK.test(q2) ? "A data-retention policy (organizational governance, not org metadata)" : CONSENT_PROCESS_ASK.test(q2) ? "A consent process (organizational governance, not org metadata)" : POLICY_ASK.test(q2) ? "Org policy authorship" : OPINION_ASK.test(q2) ? "An opinion" : DELIVERY_ASK.test(q2) ? "Message delivery" : WRITE_CODE_ASK.test(q2) ? "Code generation" : DRAFT_DOCUMENT_ASK.test(q2) ? "Document authorship (agreements, policies, memos)" : CAREER_ASK.test(q2) ? "Career/self-improvement guidance" : SHOULD_WE.test(q2) && !METADATA_NOUN.test(q2) ? "An org-decision recommendation" : void 0;
       if (outOfScopeTopic !== void 0) {
         return { kind: "out-of-scope", disclosure: outOfScopeDisclosure(outOfScopeTopic) };
       }
@@ -55576,7 +57056,22 @@ var init_funnel_utterances = __esm({
         "what validation rules exist on the Order object?",
         "show me every component that references the <PermSet> permission set",
         "is there an approval process on Opportunity?",
-        "find me anything that blocks record creation when a required field is empty"
+        "find me anything that blocks record creation when a required field is empty",
+        // biz-user register (router-v2 R2): existence-check with a look-inside.
+        "does a <Object> object exist in this org? I want to see its fields",
+        // R3 custom-permission band (DIAGNOSIS-R3 §2 rank 2 — the #1 corpus
+        // family): describe-what-it-gates and bypass/guard phrasings. The tools
+        // work (0.1.19 CustomPermission exposure); the vocabulary was missing.
+        "what does the <CustomPermission> custom permission bypass exactly?",
+        "whos allowed to bypass the validation and what is that custom permission guarding?",
+        "which custom permission gates the <FlowName> screen flow?",
+        "is there a custom permission that could let someone bypass a control?",
+        "which custom permissions have descriptions that mention bypassing something?",
+        "tell me every custom permission checked by a validation rule",
+        // R3 cross-object field-existence band (same §2 row).
+        "does Amount__c exist on any object, and which ones?",
+        "do we track a completion date anywhere I could report on?",
+        "is the <RecordType> record type only on Case or is it on other objects too?"
       ],
       "sfi.resolve": [
         "pull the <vague-field-name> field \u2014 <PermSet> implies we have one",
@@ -55591,7 +57086,26 @@ var init_funnel_utterances = __esm({
         "I keep hearing about a <fuzzy-name> flow \u2014 can you find it?",
         "what's the canonical name for the field that stores the SLA deadline?",
         "look up Status__c \u2014 which object is it on?",
-        "do we have anything for tracking escalation dates on Case?"
+        "do we have anything for tracking escalation dates on Case?",
+        // biz-user register (router-v2 R2): nickname-existence and
+        // component-type-confusion phrasings ("is that a flow or a trigger").
+        "I keep calling it the '<nickname>' object \u2014 does this org have something like that?",
+        "is <ComponentName> a flow or a trigger? I can't tell from the name",
+        "what type of component is <ComponentName> \u2014 an Apex class or a flow?",
+        // R3 existence/verification/typo band (DIAGNOSIS-R3 §2 rank 1 +
+        // trap-122-a): explicit "does X exist" asks, prove-it challenges, and
+        // is-that-the-right-name verification.
+        "does <Field__c> exist on Contact or only on Lead?",
+        "is <ComponentName> even the right name? prove it actually exists",
+        "wait, is <Name__c> a field or an object?",
+        "pull up <ComponentName> \u2014 I might have the name spelled wrong",
+        "does the <ComponentName> component actually exist in this org, yes or no?",
+        // R4 show-me corpus (DIAGNOSIS-R4 §2 lever 2): "show me / pull up / open X"
+        // where X is a bare informal name that must be RESOLVED first — the display
+        // verb over an unqualified nickname reaches resolve.
+        "show me the <nickname> thing \u2014 I'm not sure of its exact name",
+        "pull up whatever we call <nickname> around here",
+        "open the one that sounds like <fuzzy-name>"
       ],
       "sfi.capabilities": [
         "what can you actually do?",
@@ -55648,7 +57162,12 @@ var init_funnel_utterances = __esm({
         "pulse check \u2014 is this org healthy?",
         "quick status: how is the org doing right now?",
         "is there anything alarming about this org at a glance?",
-        "one-liner on org health"
+        "one-liner on org health",
+        // biz-user register (router-v2 R2): "who is changing things" asked as a
+        // people question, not a metadata question.
+        "who has been modifying things in this org the most?",
+        "who are the top contributors to changes in this org lately?",
+        "who's been making the most changes to this org lately?"
       ],
       "sfi.org_card": [
         "show me the org's basic info \u2014 edition, limits, creation date",
@@ -55680,7 +57199,25 @@ var init_funnel_utterances = __esm({
         "get me the raw component data for the Contact validation rule",
         "fetch the permission set definition for <PermSet>",
         "show me the layout metadata for Case",
-        "pull the full metadata for <FlowName>"
+        "pull the full metadata for <FlowName>",
+        // R3 show-me-the-thing band (DIAGNOSIS-R3 §2 rank 4).
+        "whats in the <PermSet> permission set?",
+        "what is the <PermSet> permission set for? the name confuses me",
+        "is the <FlowName> flow active or dormant?",
+        "can you give me the raw metadata XML for the <CustomPermission> custom permission?",
+        "pull up <ComponentName> so I can look at it",
+        // R4 show-me corpus (DIAGNOSIS-R4 §2 lever 2): the "show me X / pull up X /
+        // open X / bring up X / display X" families — display verbs over a single
+        // NAMED component reach get_component. Generic vocabulary, no org tokens.
+        "open the <FlowName> flow so I can see its definition",
+        "bring up the <ApexClass> class for me",
+        "display the metadata for the <PermSet> permission set",
+        "let me see the <ComponentName> component in full",
+        "open up <ComponentName> and show me everything about it",
+        "can you show me what the <FlowName> flow contains?",
+        "pull the definition of the <ComponentName> component",
+        "I want to see the full <ApexClass> apex class source and metadata",
+        "render the raw metadata for the <ComponentName> component"
       ],
       "sfi.list_components": [
         "whats on the Account object \u2014 give me the whole field list",
@@ -55695,7 +57232,25 @@ var init_funnel_utterances = __esm({
         "show me all the triggers on Account",
         "what approval processes are deployed?",
         "list all custom labels",
-        "give me every email template in the org"
+        "give me every email template in the org",
+        // R3 custom-permission enumeration band (DIAGNOSIS-R3 §2 rank 6) + the
+        // "can i see the validation rules" type-noun phrasings.
+        "which custom permissions exist and what do they gate?",
+        "what custom permissions are defined in this org?",
+        "pull the full custom permission inventory for the audit workpaper",
+        "can i see the validation rules on the <Object> object",
+        "is there validation on the <Object> object?",
+        "show me all the invocable apex methods",
+        // R4 show-me corpus (DIAGNOSIS-R4 §2 lever 2): "show me / pull up / open /
+        // bring up ALL the X" enumeration phrasings over a component TYPE reach
+        // list_components. Generic vocabulary, no org tokens.
+        "open the list of every flow in this org",
+        "bring up all the apex classes for me \u2014 the whole inventory",
+        "display all the custom objects we have",
+        "let me see everything of type permission set",
+        "pull up the full list of validation rules",
+        "show me the whole inventory of layouts",
+        "bring up the entire list of triggers in the org"
       ],
       "sfi.get_edges": [
         "what are the edges between <ApexClass> and the objects it touches?",
@@ -55730,7 +57285,13 @@ var init_funnel_utterances = __esm({
         "find flows that call the <ApexClass> Apex class",
         "which flows have a Get Records step on the Account object?",
         "search for flows that send emails",
-        "find every flow that creates an Opportunity"
+        "find every flow that creates an Opportunity",
+        // R3 q738-class boundary recovery: custom-permission checks inside flow
+        // XML, subflow-by-name, and field-stamping searches.
+        "does any flow reference the <CustomPermission> custom permission to skip a validation rule?",
+        "which custom permissions are checked inside flows?",
+        "find the flow that fires the <SubflowName> subflow",
+        "is there a flow that stamps <Field__c> when the record closes?"
       ],
       "sfi.get_naming_convention_report": [
         "do our field names follow any consistent pattern?",
@@ -55819,7 +57380,11 @@ var init_funnel_utterances = __esm({
         "pull a random sample of Opportunity records",
         "show me what Account data actually looks like",
         "grab a handful of Order records for me to inspect",
-        "give me a sample of 10 Opportunities with Stage = Prospecting"
+        "give me a sample of 10 Opportunities with Stage = Prospecting",
+        // biz-user register (router-v2 R2): single-record lookup by an id the
+        // user has in hand, asking for every field value.
+        "can you pull up the specific record for id <RecordId>? I need to see all their field values",
+        "show me one actual record with every field value filled in"
       ],
       "sfi.live_field_population": [
         "what percentage of Contacts have the Email field filled in?",
@@ -55835,7 +57400,10 @@ var init_funnel_utterances = __esm({
         "how many people are in the queue right now?",
         "show me group sizes across all public groups",
         "how many members does the Sales territory group have?",
-        "how are Cases distributed by Status right now?"
+        "how are Cases distributed by Status right now?",
+        // biz-user register (router-v2 R2): distribution-by-field phrasing.
+        "how are <Object> records distributed by their Type field?",
+        "breakdown of records by picklist value \u2014 how many land in each bucket?"
       ],
       "sfi.live_stale_records": [
         "which Cases haven't been updated in over 90 days?",
@@ -55909,6 +57477,58 @@ var init_funnel_utterances = __esm({
         "which license types do we have and how many are used?",
         "how many Salesforce licenses are actually being used vs assigned?"
       ],
+      // ENGINE-ARC §2a — assignment rosters (holders of a grantor). Vocabulary is
+      // the HOLDER direction (who has / assigned to / roster / everyone with);
+      // the GRANTS direction ("which permission sets grant edit on X") stays owned
+      // by sfi.effective_permissions — do not add grants-phrasings here.
+      "sfi.live_permset_holders": [
+        "who has the <PermSet> permission set?",
+        "list everyone assigned the <PermSet> permission set",
+        "which users hold the <PermSetGroup> permission set group?",
+        "show me the roster of users with the <PermSet> permission set",
+        "how many users are assigned <PermSet> right now \u2014 directly or through a group?",
+        "name-by-name list of users with the <Profile> profile",
+        "which users are in the <PermSetGroup> permission set group?",
+        "who holds <PermSet>, including via permission set groups?",
+        "all users assigned the System Administrator profile",
+        "holder count for the <PermSet> permission set \u2014 I need it for an audit"
+      ],
+      // ENGINE-ARC §2c — the perm-set-less sweep (anti-join). Dormancy-only
+      // phrasings ("who hasn't logged in") stay owned by sfi.live_inactive_users.
+      "sfi.live_zombie_accounts": [
+        "which active users have no permission sets assigned?",
+        "find zombie accounts \u2014 login access but zero permission sets",
+        "users who can log in but have no permission set assignments",
+        "which users have nothing assigned beyond their profile?",
+        "active accounts with zero permission set or group assignments",
+        "audit accounts that can still log in but hold no perm sets"
+      ],
+      // ENGINE-ARC §2b — runtime queue/public-group membership. "Which queues are
+      // EMPTY" (hygiene sweep over declared metadata) stays owned by
+      // sfi.empty_queues_and_groups; this family is the who's-in-it roster.
+      "sfi.live_group_members": [
+        "who's in the <QueueName> queue right now?",
+        "list the members of the <GroupName> public group",
+        "which users are in the Support queue?",
+        "show me the current membership of the <QueueName> queue",
+        "can the <QueueName> queue own Case records?",
+        "what objects does the <QueueName> queue support?",
+        "members of the <GroupName> group \u2014 including any nested groups or roles",
+        "who is actually in this queue in the live org, not the vault snapshot?"
+      ],
+      // ENGINE-ARC §3 — reverse direction: what a named USER holds. The GRANTS
+      // direction ("what can <Profile> do", "expand the <PermSetGroup>") stays
+      // owned by sfi.effective_permissions; this family is user → grantors.
+      "sfi.live_user_permsets": [
+        "what permission sets does <UserName> have?",
+        "which permission sets is <UserName> assigned right now?",
+        "list <UserName>'s permission set and permission set group assignments",
+        "what does the user <UserName> hold \u2014 direct sets and via groups?",
+        "which permission set groups is <UserName> a member of?",
+        "show me every permission set assigned to <UserName>, with expirations",
+        "does <UserName> have any expiring permission set assignments?",
+        "what perm sets is jane.doe@example.com assigned in the live org?"
+      ],
       "sfi.live_consent": [
         "which Contacts have opted out of email?",
         "show me consent status for marketing contacts",
@@ -55931,7 +57551,9 @@ var init_funnel_utterances = __esm({
         "which users can see the Executive dashboards folder?",
         "who can access the shared document library?",
         "folder-level access for the Finance reports",
-        "are any report or dashboard folders publicly accessible?"
+        "are any report or dashboard folders publicly accessible?",
+        // biz-user register (router-v2 R2): single-report ownership question.
+        "the <ReportName> report \u2014 who owns it and who can run it?"
       ],
       "sfi.live_email_template_usage": [
         "which email templates are actually being used?",
@@ -55983,7 +57605,10 @@ var init_funnel_utterances = __esm({
         "executive summary of org risk",
         "what should I be worried about before we go live?",
         "pull together the top risks I need to present to leadership",
-        "is there anything that would block a production release right now?"
+        "is there anything that would block a production release right now?",
+        // biz-user register (router-v2 R2): quality asked as a grade.
+        "is our Salesforce org well-architected? would you give it a passing grade?",
+        "if an outside expert graded this org's setup, what would they flag?"
       ],
       "sfi.field_cleanup_candidates": [
         "which fields can we safely delete?",
@@ -56061,7 +57686,22 @@ var init_funnel_utterances = __esm({
         "what's the net permission for a user with <Profile> and <PermSet>?",
         "does this user actually have delete access on Account?",
         "what objects can the <Profile> profile read?",
-        "effective read/write/delete access for <Profile> on Order"
+        "effective read/write/delete access for <Profile> on Order",
+        // R3 PSG-expansion band (DIAGNOSIS-R3 permissions family): what a member
+        // of a permission set GROUP ends up with — effective_permissions expands
+        // PSGs (verified). "Which USERS are in the group / hold the set"
+        // (permset-user-roster) is now answered LIVE by sfi.live_permset_holders
+        // (ENGINE-ARC §2a) — that tool owns the holder-roster vocabulary.
+        // permset-group-grants is a PARTIAL live flip (§4): live_permset_holders
+        // surfaces PSG containment via PermissionSetGroupComponent, while the
+        // 2-hop "which PSG grants custom permission X" chain stays an honest gap
+        // note on that intent.
+        "what does a user get through the <PermSetGroup> permission set group?",
+        "expand the <PermSetGroup> permission set group \u2014 every permission a member ends up with",
+        "if someone is assigned the <PermSetGroup> permission set group, do they automatically get <CustomPermission>?",
+        "what custom permissions does a new hire end up with after all their permission set group assignments?",
+        "can a user in the <PermSetGroup> permission set group edit these records?",
+        "walk me through how permission set group inheritance works here, with a real group as the example"
       ],
       "sfi.who_can_run": [
         "who can run the <Report> report?",
@@ -56085,7 +57725,12 @@ var init_funnel_utterances = __esm({
         "a user is getting access denied on Opportunity \u2014 what's wrong?",
         "why is this record invisible to a specific user?",
         "I need to figure out why a user can't open this record",
-        "user says they get a 'No access' error on a Contact record \u2014 what gives?"
+        "user says they get a 'No access' error on a Contact record \u2014 what gives?",
+        // R3 access-diagnostics band (DIAGNOSIS-R3 permissions family): symptom
+        // phrasings — greyed-out fields, blocked edits, blocked reassignment.
+        "a user cant edit the <Field__c> field on a record, they say its greyed out \u2014 why?",
+        "why cant a user with the <Profile> profile reassign the Case owner?",
+        "a user reports the record is read-only for them \u2014 which layer blocks the edit?"
       ],
       "sfi.layout_for_user": [
         "what page layout does <Profile> see on Case?",
@@ -56101,7 +57746,11 @@ var init_funnel_utterances = __esm({
         "what can a specific user actually do in the org?",
         "check if <Username> can create Opportunities",
         "what record types can this user access on Case?",
-        "what flows can users with the <Profile> profile actually run?"
+        "what flows can users with the <Profile> profile actually run?",
+        // R3 access-diagnostics band: missing-button / failing-action symptoms.
+        "a user says the Convert button is missing on a Lead \u2014 why?",
+        "why does the send action fail for one user \u2014 do they need the <PermSet> permission set?",
+        "which permission is this user missing to perform the action?"
       ],
       "sfi.profile_security": [
         "how locked down is the <Profile> profile?",
@@ -56141,7 +57790,9 @@ var init_funnel_utterances = __esm({
         "which objects have tabs hidden from the support profile?",
         "show me tab settings for the <Profile> profile",
         "which tabs are set to 'Default Off' for a specific profile?",
-        "which tabs are visible to users with the <Profile> profile?"
+        "which tabs are visible to users with the <Profile> profile?",
+        // biz-user register (router-v2 R2): imperative "list its tabs" shape.
+        "the <Profile> profile \u2014 what does it have access to? list its tabs"
       ],
       "sfi.lifecycle_process": [
         "what's the Case lifecycle \u2014 statuses and transitions?",
@@ -56149,7 +57800,11 @@ var init_funnel_utterances = __esm({
         "what are the valid Lead status transitions?",
         "describe the record lifecycle for Order",
         "what's the path an Account goes through from creation to active?",
-        "what happens when an Opportunity moves to Closed Won?"
+        "what happens when an Opportunity moves to Closed Won?",
+        // biz-user register (router-v2 R2): status-transition asked as "what
+        // kicks in when the value flips".
+        "when the Status field flips to Resolved, what processes kick in for that value transition?",
+        "what happens behind the scenes when a record moves to a new stage?"
       ],
       "sfi.layout_assignments": [
         "which layouts are assigned to which profiles on Case?",
@@ -56337,7 +57992,9 @@ var init_funnel_utterances = __esm({
         "compare the Case validation rules in two orgs",
         "what's different between the <Profile> profile in sandbox vs prod?",
         "compare the <ApexClass> class across environments",
-        "are these two record types actually different or just named differently?"
+        "are these two record types actually different or just named differently?",
+        // biz-user register (router-v2 R2): duplicate-automation confusion.
+        "why do we have two triggers on the same object \u2014 what does each one do differently?"
       ],
       "sfi.export_manifest": [
         "export the full org manifest",
@@ -56369,7 +58026,9 @@ var init_funnel_utterances = __esm({
         "who has delete access to Account?",
         "object-level permission audit for Contact",
         "show me which profiles have full CRUD on custom object <ObjectName>",
-        "which profiles have Create access on the Case object?"
+        "which profiles have Create access on the Case object?",
+        // biz-user register (router-v2 R2): group-membership create-access ask.
+        "can members of <GroupName> create <Object> records, and where does that access come from?"
       ],
       "sfi.recordtype_availability": [
         "which record types on Case are available to the Support profile?",
@@ -56391,7 +58050,10 @@ var init_funnel_utterances = __esm({
         "describe this org to me like I just joined the team",
         "how big is this org \u2014 fields, flows, classes, the works?",
         "what's the overall complexity of this org?",
-        "give me a lay of the land for this Salesforce environment"
+        "give me a lay of the land for this Salesforce environment",
+        // biz-user register (router-v2 R2): the new-joiner altitude idioms.
+        "I just joined this team \u2014 what's the 10,000-foot view of what's in this Salesforce org?",
+        "give me the bird's-eye view of this org for a newcomer"
       ],
       "sfi.domain_clusters": [
         "what functional areas does this org cover?",
@@ -56430,7 +58092,19 @@ var init_funnel_utterances = __esm({
         "before I add a new flow to Contact, what else is already running on save?",
         "which flows fire synchronously on Lead save?",
         "complete save-event automation inventory for the Account object",
-        "what happens behind the scenes when I create a new Contact?"
+        "what happens behind the scenes when I create a new Contact?",
+        // biz-user register (router-v2 R2): terse "show me its automation" shape.
+        "the <Object> object \u2014 can you show me its automation?",
+        // R3 save-cascade band (DIAGNOSIS-R3 §2 rank 7): terse "whats on save",
+        // event-split phrasings, apex-on-insert, and the automation footprint.
+        "whats on save for the <Object> object?",
+        "how many automations fire when a record gets saved?",
+        "what apex runs on Contact insert?",
+        "list the flows that run on Contact insert",
+        "which flows are triggered by Case creation vs Case update?",
+        "whats the automation footprint on the <Object> object \u2014 flows, triggers, everything together?",
+        "why did the flow not fire on my lead update \u2014 what is even wired to Lead saves?",
+        "does anything on <Object> save update a date field automatically?"
       ],
       "sfi.why_field_changed": [
         "which flows write to Contact.Status__c?",
@@ -56467,7 +58141,28 @@ var init_funnel_utterances = __esm({
         "what's the happy path through <FlowName>?",
         "does <FlowName> have any error handling?",
         "what variables does <FlowName> use?",
-        "which object does <FlowName> primarily operate on?"
+        "which object does <FlowName> primarily operate on?",
+        // biz-user register (router-v2 R2): non-technical phrasings from the
+        // business-user persona misses — purpose-of-flow asked as a business
+        // question, and the "is that a flow or a trigger" type-confusion shape.
+        "there's a flow called <FlowName> \u2014 what is it for? what business process does it support?",
+        "what does the <FlowName> flow do for the business?",
+        "<FlowName> \u2014 is that a flow or a trigger? what does it invoke?",
+        "is <ComponentName> an Apex class or a flow? I want to see what it does",
+        // R3 flow-explain band (DIAGNOSIS-R3 §2 rank 3): indirect explanation
+        // phrasings — orchestrate/breakdown/what-triggers-it/fires-on-update.
+        "before i touch the <FlowName> flow, what does it even do?",
+        "what does the <FlowName> flow orchestrate?",
+        "give me a breakdown of the <FlowName> flow",
+        "what triggers the <FlowName> flow \u2014 a record change, a schedule, or a button?",
+        "does <FlowName> fire on update too or just on insert?",
+        "which record type does the <FlowName> flow assign to the Case?",
+        "the <FlowName> screen flow \u2014 walk me through its screens and decisions",
+        // R3 flow-diagnostics band ("why did it NOT fire / not stamp"):
+        "why did the <FlowName> flow NOT fire when the record was updated?",
+        "why is the <FlowName> flow not sending the confirmation email \u2014 walk the decision branches",
+        "the flow didnt stamp the date when the stage moved \u2014 why not?",
+        "a reviewer says the <FlowName> flow is skipping records \u2014 what does it actually gate?"
       ],
       "sfi.explain_apex_method": [
         "what does the <MethodName> method in <ApexClass> do?",
@@ -56475,7 +58170,12 @@ var init_funnel_utterances = __esm({
         "walk me through the logic of <ApexClass>.<MethodName>",
         "what does this method return and what does it modify?",
         "explain the business logic in the <MethodName> method",
-        "what does the AccountController class do?"
+        "what does the AccountController class do?",
+        // biz-user register (router-v2 R2): whole-class purpose questions and the
+        // "Trigger in the name but is it a test class" type-confusion shape.
+        "we have an Apex class called <ClassName> \u2014 what does it do and what objects does it touch?",
+        "is <ClassName> an Apex test class or an actual trigger?",
+        "that class has Trigger in its name \u2014 is it actually a test class?"
       ],
       "sfi.explain_formula": [
         "what does this formula field actually calculate?",
@@ -56499,7 +58199,10 @@ var init_funnel_utterances = __esm({
         "which processes are candidates for Flow migration?",
         "what Process Builder is left that we need to retire?",
         "identify Process Builder processes that would be straightforward to convert",
-        "which Process Builders should we migrate to Flow first?"
+        "which Process Builders should we migrate to Flow first?",
+        // biz-user register (router-v2 R2): "sunset/retire" business phrasing.
+        "which automation is Salesforce going to sunset that we need to replace?",
+        "what legacy automation is being retired that we still depend on?"
       ],
       "sfi.unassigned_permission_sets": [
         "are there permission sets that aren't assigned to anyone?",
@@ -56507,7 +58210,12 @@ var init_funnel_utterances = __esm({
         "find permission sets that are effectively dead \u2014 no assignments",
         "show me unassigned permission sets we could clean up",
         "permission sets nobody has \u2014 are there any?",
-        "which permission sets aren't assigned to any user?"
+        "which permission sets aren't assigned to any user?",
+        // biz-user register (router-v2 R2): single-perm-set assignment questions
+        // ("is X assigned to anyone") — the premise-trap family phrasing.
+        "is the <PermSet> permission set assigned to anyone?",
+        "is <PermSet> assigned to any active users right now?",
+        "who has the <PermSet> permission set assigned and what does it let them do?"
       ],
       "sfi.empty_queues_and_groups": [
         "are there any queues with no members?",
@@ -56523,7 +58231,9 @@ var init_funnel_utterances = __esm({
         "give me a technical debt rating for this Salesforce org",
         "debt score breakdown \u2014 what's contributing most?",
         "quantify the technical debt in this org",
-        "what's the overall technical debt score for this org?"
+        "what's the overall technical debt score for this org?",
+        // biz-user register (router-v2 R2): quality asked as a grade.
+        "overall, is this org in good shape or carrying a lot of debt \u2014 passing grade or not?"
       ],
       "sfi.code_quality_audit": [
         "how good is our Apex code quality?",
@@ -56591,7 +58301,9 @@ var init_funnel_utterances = __esm({
         "impact of making Contact.External_Id__c required",
         "can I safely make this field required without breaking flows?",
         "what automation would break if I make this field mandatory?",
-        "what would break if I made Account.Website required?"
+        "what would break if I made Account.Website required?",
+        // biz-user register (router-v2 R2): "I want to set X to required" ask.
+        "I want to set <Field__c> to required \u2014 can you check what flows and Apex would break?"
       ],
       "sfi.what_if_deactivate_flow": [
         "what breaks if I deactivate <FlowName>?",
@@ -56599,7 +58311,22 @@ var init_funnel_utterances = __esm({
         "impact of deactivating the Case assignment flow",
         "can I safely deactivate <FlowName> without breaking anything?",
         "what would stop working if I switch off <FlowName>?",
-        "what happens if I deactivate the <FlowName> flow?"
+        "what happens if I deactivate the <FlowName> flow?",
+        // biz-user register (router-v2 R2): "can you deactivate it safely" and
+        // "impact if we turn it off" phrasings (premise-trap family).
+        "can you deactivate <FlowName> safely? I need to know what depends on it",
+        "we have a <ProcessName> process that runs on these records \u2014 what's the impact if we turn it off?",
+        // R3 what-if band (DIAGNOSIS-R3 flows family + §5c simulation frames):
+        // imperative-plus-impact phrasings the write gate now carves out.
+        "deactivate <FlowName> and tell me the impact",
+        "deactivating <FlowName> \u2014 consequences?",
+        "what happens if the <FlowName> flow is turned off during a busy period?",
+        "deactivate the <FlowName> flow \u2014 what happens to new records?",
+        "deactivate <FlowName> and tell me what stops recalculating",
+        "does deactivating <FlowName> stop the confirmation emails?",
+        "when I deactivate <FlowName>, does the review process just stall?",
+        "consequences of deactivating the <FlowName> flow?",
+        "what would happen if the <FlowName> flow were deactivated?"
       ],
       "sfi.what_if_disable_trigger": [
         "what breaks if I disable the Contact trigger?",
@@ -56641,7 +58368,10 @@ var init_funnel_utterances = __esm({
         "build a data dictionary I can share with the data team",
         "export field descriptions and types for all custom objects",
         "generate a schema reference document",
-        "generate a data dictionary for the Contact object"
+        "generate a data dictionary for the Contact object",
+        // biz-user register (router-v2 R2): "reference sheet" business phrasing.
+        "our business team needs a reference sheet for the <Object> object \u2014 field names, types, required vs optional",
+        "make a field reference sheet the business team can read"
       ],
       "sfi.generate_admin_handbook": [
         "write an admin handbook for this org",
@@ -56657,7 +58387,9 @@ var init_funnel_utterances = __esm({
         "create a high-level architecture summary for stakeholders",
         "document the overall structure of this Salesforce implementation",
         "generate an architecture diagram description for this org",
-        "write an architecture overview document for this Salesforce org"
+        "write an architecture overview document for this Salesforce org",
+        // biz-user register (router-v2 R2): altitude idiom for leadership.
+        "the leadership team wants the 10,000-foot architecture picture of our Salesforce org"
       ],
       "sfi.generate_sharing_summary": [
         "generate a sharing model summary for this org",
@@ -56698,12 +58430,18 @@ var init_funnel_utterances = __esm({
         "subflow map \u2014 which flows call other flows?"
       ],
       "sfi.downstream_effects": [
-        "what does changing <Field__c> ripple out to?",
+        "what does changing <Field__c> ripple out to downstream?",
         "show me the downstream effects of modifying <ApexClass>",
-        "if I change <FlowName>, what else is affected?",
+        "if I change <FlowName>, what else is affected downstream?",
         "downstream impact of updating the Case status picklist",
         "what does it affect if <ComponentName> changes?",
-        "what side effects does the AccountTrigger handler produce downstream?"
+        "what side effects does the AccountTrigger handler produce downstream?",
+        // self-recall reinforcement (router-v2 R2): the two paraphrase-only
+        // utterances above ("what else is affected", "what does it affect")
+        // shared no vocabulary with the tool's own name and lost the tie to
+        // get_impact — anchor the downstream/effects terms.
+        "what are the downstream effects if I change <FlowName>?",
+        "show downstream effects of a change to <ComponentName>"
       ],
       "sfi.test_coverage_for_method": [
         "what tests cover the <MethodName> method?",
@@ -56783,7 +58521,12 @@ var init_funnel_utterances = __esm({
         "what's the semantic meaning of Status__c on Order?",
         "what does Amount__c represent \u2014 is it revenue, cost, or something else?",
         "in plain English, what does this field track?",
-        "what does the External_Id__c field on Account actually mean in this org?"
+        "what does the External_Id__c field on Account actually mean in this org?",
+        // biz-user register (router-v2 R2): label-first "what is it really for /
+        // who sets it" phrasings from the business-user misses.
+        "what is the <Field__c> field really for in this org?",
+        "the bad email field \u2014 what does it represent and who sets it?",
+        "what does that field mean in context \u2014 is it set by automation or by users, and what object is it on?"
       ],
       "sfi.disambiguate_concepts": [
         "we have both Priority__c and Case.Priority \u2014 which one should I use?",
@@ -56801,7 +58544,9 @@ var init_funnel_utterances = __esm({
         "is Amount__c auto-populated or user-entered?",
         "where does the data in this field come from?",
         "is this field set by a trigger, a flow, or does a user type it in?",
-        "trace the origin of values in <Field__c>"
+        "trace the origin of values in <Field__c>",
+        // biz-user register (router-v2 R2): "how does it get its value" shape.
+        "how does the <Field__c> field get its value \u2014 is it a formula or is something writing to it?"
       ],
       "sfi.find_field_anywhere": [
         "find all objects that have a field called External_Id__c",
@@ -56985,7 +58730,28 @@ var init_funnel_utterances = __esm({
         "which layouts include the <ComponentName> component?",
         "which flows invoke <ComponentName>?",
         "where is this custom label used?",
-        "what uses the <PermSet> permission set \u2014 show me all assignments and references"
+        "what uses the <PermSet> permission set \u2014 show me all assignments and references",
+        // R3 reverse custom-permission grant band (DIAGNOSIS-R3 §2 rank 5): who
+        // holds / which perm sets turn on / which profiles enable a custom
+        // permission — the reverse lookup shipped in 0.1.19; the vocabulary here.
+        "who holds the <CustomPermission> custom permission and which perm sets grant it?",
+        "which permission sets or permission set groups turn on <CustomPermission>?",
+        "which profiles enable the <CustomPermission> custom permission directly \u2014 not perm sets?",
+        "is <CustomPermission> granted anywhere besides the <PermSet> permission set?",
+        "i need the granting perm set for the <CustomPermission> custom permission",
+        "how could a user have gotten the <CustomPermission> custom permission?",
+        "what perm set gives access to the <ComponentName> component?",
+        "who is allowed to bypass the validation \u2014 which custom permission guards it and who holds it?",
+        // R4 custom-permission VERIFY-FIRST band (DIAGNOSIS-R4 lever 3, the 5 R3
+        // residuals): a NAMED custom permission where the ask combines "what does
+        // it control" WITH "who has / who grants it", or verifies a specific
+        // granting perm set ("granted by X or a different one"). These name a
+        // specific custom permission and want the reverse-grant answer.
+        "the <CustomPermission> custom permission \u2014 what does it control and who has it?",
+        "does the <CustomPermission> custom permission get granted by the <PermSet> perm set or a different one?",
+        "which permission set enables the <CustomPermission> custom permission, and what does that permission gate?",
+        "for the <CustomPermission> custom permission, tell me both the granting permission set and what it lets people do",
+        "is <CustomPermission> actually granted by <PermSet>, or does the grant come from somewhere else?"
       ],
       "sfi.installed_package_catalog": [
         "what managed packages are installed in this org?",
@@ -57034,7 +58800,7 @@ var init_funnel_utterances = __esm({
 });
 
 // ../mcp/dist/src/semantic-funnel.js
-var STOPWORDS, SYNONYMS, PHRASE_SYNONYMS3, applyPhraseSynonyms3, tokenize6, TOOL_KEYWORDS, PLANE_OVERRIDES, planeForTool, EXCLUDED_FROM_CANDIDATES, liveRequiredForPlane, buildPlaneByTool, cachedPlanes, getPlaneByTool, resolveCandidatePlane, EXPANSION_WEIGHT, expandWeighted, buildToolDocs, cached, buildIndex, getFunnelIndex, CONF_HIGH_TOP1, CONF_HIGH_MARGIN, CONF_HIGH_COVERAGE, CONF_FLOOR_TOP1, CONF_MIN_COVERAGE, CONF_LOW_MARGIN, CONF_RESCUE_TOP1, CONF_RESCUE_COVERAGE, CONF_LOW_COVERAGE, funnelConfidence, semanticCandidates;
+var STOPWORDS, SYNONYMS, PHRASE_SYNONYMS3, applyPhraseSynonyms3, tokenize6, TOOL_KEYWORDS, PLANE_OVERRIDES, planeForTool, EXCLUDED_FROM_CANDIDATES, liveRequiredForPlane, buildPlaneByTool, cachedPlanes, getPlaneByTool, resolveCandidatePlane, EXPANSION_WEIGHT, expandWeighted, CORPUS_EXCLUDED, buildToolDocs, cached, buildIndex, getFunnelIndex, CONF_HIGH_TOP1, CONF_HIGH_MARGIN, CONF_HIGH_COVERAGE, CONF_FLOOR_TOP1, CONF_MIN_COVERAGE, CONF_LOW_MARGIN, CONF_RESCUE_TOP1, CONF_RESCUE_COVERAGE, CONF_LOW_COVERAGE, funnelConfidence, semanticCandidates;
 var init_semantic_funnel = __esm({
   "../mcp/dist/src/semantic-funnel.js"() {
     "use strict";
@@ -57143,6 +58909,15 @@ var init_semantic_funnel = __esm({
       many: ["count", "number"],
       show: ["sample", "records"],
       sample: ["records", "show"],
+      // R4 show-me corpus (DIAGNOSIS-R4 §2 lever 2): display verbs → fetch/list the
+      // component's metadata. EXPANSION_WEIGHT keeps originals dominant, so these
+      // only tip a question that is ALREADY display-shaped ("open X", "pull up X",
+      // "bring up X", "display X") toward get_component / list_components without
+      // hijacking real intents.
+      open: ["fetch", "component", "metadata", "definition"],
+      display: ["fetch", "component", "metadata", "list"],
+      bring: ["fetch", "component", "metadata", "list"],
+      pull: ["fetch", "component", "metadata"],
       // change / audit / freshness
       changed: ["modified", "change", "history", "audit"],
       change: ["modified", "history", "changed"],
@@ -57275,7 +59050,57 @@ var init_semantic_funnel = __esm({
       untested: ["coverage", "gaps", "test", "tests"],
       // queue / assignment routing family
       queue: ["assignment", "routing", "owner", "group"],
-      routed: ["assignment", "queue", "rule", "routing"]
+      routed: ["assignment", "queue", "rule", "routing"],
+      // ---- router-v2 R2 biz-user vocabulary bridges. Grown from the
+      // business-user persona misses on the additions-tuning set; every entry is
+      // GENERIC business English mapped to Salesforce vocabulary — no org terms.
+      // "which automation gets sunset / retired" → legacy-migration vocabulary
+      sunset: ["retire", "retired", "deprecated", "migrate", "legacy", "replace"],
+      retiring: ["sunset", "deprecated", "migrate", "legacy"],
+      // "when the status flips to X" → transition vocabulary
+      flips: ["changes", "transition", "moves", "value", "status"],
+      // "who are the top contributors" → change-activity vocabulary
+      contributors: ["changes", "modified", "activity", "churn"],
+      // "how are records distributed by X" → grouped-count vocabulary
+      distributed: ["count", "group", "grouped", "breakdown"],
+      // "would you give it a passing grade" → health/risk vocabulary
+      grade: ["risk", "health", "score", "debt"],
+      graded: ["risk", "health", "score", "debt"],
+      architected: ["architecture", "risk", "health", "design"],
+      // "the report my boss uses / the thing she made" → ownership vocabulary
+      boss: ["owner", "user"],
+      made: ["created", "built"],
+      // ---- router-v2 R3 vocabulary bridges. Grown from the v0.1.22 labeled-miss
+      // permissions/flows families (DIAGNOSIS-R3 §2); every entry is GENERIC
+      // Salesforce/business vocabulary — no org terms — and safe at
+      // EXPANSION_WEIGHT (originals always win).
+      // custom-permission family: bypass / gate / guard / unlock verbs → the
+      // permission vocabulary the tool docs actually use.
+      bypass: ["permission", "custom", "validation", "skip"],
+      bypasses: ["bypass", "permission", "custom", "validation"],
+      bypassing: ["bypass", "permission", "custom", "validation"],
+      gate: ["permission", "custom", "guard", "control"],
+      gates: ["gate", "permission", "custom", "guard"],
+      gated: ["gate", "permission", "custom"],
+      guarding: ["gate", "permission", "custom", "validation"],
+      unlock: ["grant", "permission", "access", "enable"],
+      unlocks: ["grant", "permission", "access", "enable"],
+      // PSG-expansion family: expand/inheritance → effective-permission union.
+      expand: ["effective", "permission", "group", "union"],
+      inheritance: ["group", "permission", "effective", "union"],
+      inherits: ["group", "permission", "effective", "union"],
+      // access-diagnostics family: greyed-out / read-only symptom words.
+      greyed: ["edit", "editable", "access", "security", "field"],
+      grayed: ["edit", "editable", "access", "security", "field"],
+      // flow-diagnostics family: "didn't stamp the date", "what does it
+      // orchestrate", "the flow is skipping records".
+      stamp: ["writes", "sets", "populates", "updates", "flow"],
+      stamps: ["writes", "sets", "populates", "updates", "flow"],
+      orchestrate: ["flow", "subflow", "invoke", "explain"],
+      orchestrates: ["flow", "subflow", "invoke", "explain"],
+      skipping: ["skip", "bypass", "decision", "flow"],
+      // automation-footprint family (what_happens_on_save / risk report).
+      footprint: ["automation", "inventory", "overview", "save"]
     };
     PHRASE_SYNONYMS3 = [
       ["social security number", "ssn"],
@@ -57287,7 +59112,18 @@ var init_semantic_funnel = __esm({
       // becomes 'break' (→ impact/dependency synonyms) + 'down' — the impact
       // expansion hijacks the ranking. Collapse the phrase to the single token
       // 'breakdown' (whose SYNONYMS entry bridges to explain/overview/walk).
-      ["break down", "breakdown"]
+      ["break down", "breakdown"],
+      // router-v2 R2 biz-user idioms: altitude metaphors are OVERVIEW asks
+      // ("10,000-foot view" survives tokenization as "...-foot view"), and
+      // "kicks in" is the business phrasing of "fires".
+      ["foot view", "overview"],
+      ["birds eye view", "overview"],
+      ["bird's eye view", "overview"],
+      ["big picture", "overview"],
+      ["lay of the land", "overview"],
+      ["kicks in", "fires"],
+      ["kick in", "fire"],
+      ["reference sheet", "dictionary"]
     ].sort((a2, b2) => b2[0].length - a2[0].length);
     applyPhraseSynonyms3 = (lower) => {
       let out = lower;
@@ -57311,7 +59147,7 @@ var init_semantic_funnel = __esm({
       return out;
     };
     TOOL_KEYWORDS = {
-      "sfi.list_components": "list inventory enumerate catalog all what do we have how many exist objects fields custom fields how many fields on object contact account lead opportunity case metadata count layouts list views triggers validation rules record types web links flows classes triggers profiles permission sets layouts record types validation rules approval processes reports dashboards omniscripts custom standard relationship child parent inactive active picklist values which flows are inactive active draft obsolete flows triggers rules by status enumerate components",
+      "sfi.list_components": "list inventory enumerate catalog all what do we have how many exist objects fields custom fields how many fields on object contact account lead opportunity case metadata count layouts list views triggers validation rules record types web links flows classes triggers profiles permission sets layouts record types validation rules approval processes reports dashboards omniscripts custom standard relationship child parent inactive active picklist values which flows are inactive active draft obsolete flows triggers rules by status enumerate components custom permissions defined exist inventory what do they gate",
       "sfi.capabilities": "what can you do help capabilities what can i ask how do i use",
       "sfi.automation_risk_report": "objects more than one multiple triggers per object trigger quality automation risk",
       "sfi.live_group_count": "how many users assigned to profile membership group count",
@@ -57383,9 +59219,12 @@ var init_semantic_funnel = __esm({
       }
       return w2;
     };
+    CORPUS_EXCLUDED = /* @__PURE__ */ new Set(["sfi.route_question"]);
     buildToolDocs = () => {
       const docs = /* @__PURE__ */ new Map();
       for (const tool of V01_TOOLS) {
+        if (CORPUS_EXCLUDED.has(tool.name))
+          continue;
         const nameWords = tool.name.replace(/^sfi\./, "").replace(/_/g, " ");
         const keywords = TOOL_KEYWORDS[tool.name] ?? "";
         const utterances = (FUNNEL_UTTERANCES[tool.name] ?? []).join(" ");
@@ -57563,7 +59402,7 @@ import { createHash as createHash7 } from "node:crypto";
 import { readFile as readFile82 } from "node:fs/promises";
 import { join as join23, resolve as resolve3 } from "node:path";
 import { z as z115 } from "zod";
-var RESOLVE_FALLBACK_MAX_TOKENS, SAVE_ORDER_INTENTS, SINGLE_ENTITY_INTENTS, COMPARISON_ASIDE, stripComparisonAside, tryResolveFallback, routeQuestionInputSchema, routeTrust, clarificationIdFor, selectedEntityArgsForRoute, extractEntityQuery, inferEntityTypes, normLiteral, refineEntityResolution, resolveParentQualifier, applyGlossaryAliases, entityAmbiguityRequiresClarification, hygienicClarificationOptions, splitCompoundQuestion, mixedInventoryAndStoragePlan, PLAN_FAMILY, ASSESSMENT_FAMILY, ROUTE_PREAMBLE_TOOLS, TOOL_COMPATIBLE_TYPES, ACCESS_FLAVORED_TOOLS, resolvedTypeForGuard, applyComponentTypeGuard, REGEX_BONUS, resolveActiveVaultAlias, buildRouteToolArgsMap, mergeRouteHintsIntoCandidates, invokeFromArgsMap, rerankForMode, MARGIN, FUNNEL_PRIMARY_MIN_SCORE, DESTRUCTIVE_TOOL, INFORMATIONAL_IMPACT_TOOL, planesDiverge, LIVE_DATA_SIGNAL, resolvePlaneTie, risksDiverge, marginClarification, LIVE_DISCLOSURE_LOOKAHEAD, liveConsentDisclosure, guidanceForMode, buildFunnelCandidates, routerMode, REFUSAL_INTENT, REFUSAL_GAP, refusalResponse, CONTEXT_SAVE_ORDER_TOOLS, CONTEXT_TOOL_ARG_KEYS, GENERIC_SCHEMA_INTENTS, contextArgsFor, buildContextContinuation, routeQuestionHandler;
+var RESOLVE_FALLBACK_MAX_TOKENS, SAVE_ORDER_INTENTS, SINGLE_ENTITY_INTENTS, COMPARISON_ASIDE, stripComparisonAside, tryResolveFallback, routeQuestionInputSchema, routeTrust, clarificationIdFor, selectedEntityArgsForRoute, isToolNameMention, extractEntityQuery, NAME_IGNORABLE_WORD, looksLikeComponentName, extractExistenceProbeToken, inferEntityTypes, normLiteral, refineEntityResolution, resolveParentQualifier, applyGlossaryAliases, questionAssertsNameMultiplicity, entityAmbiguityRequiresClarification, hygienicClarificationOptions, clarificationOptionIds, splitCompoundQuestion, mixedInventoryAndStoragePlan, PLAN_FAMILY, ASSESSMENT_FAMILY, ROUTE_PREAMBLE_TOOLS, SINGLE_COMPONENT_TARGET_TOOLS, routeTargetsSingleComponent, TOOL_COMPATIBLE_TYPES, ACCESS_FLAVORED_TOOLS, resolvedTypeForGuard, applyComponentTypeGuard, REGEX_BONUS, resolveActiveVaultAlias, buildRouteToolArgsMap, mergeRouteHintsIntoCandidates, invokeFromArgsMap, rerankForMode, MARGIN, FUNNEL_PRIMARY_MIN_SCORE, DESTRUCTIVE_TOOL, INFORMATIONAL_IMPACT_TOOL, planesDiverge, LIVE_DATA_SIGNAL, resolvePlaneTie, isCompoundPlaneAsk, risksDiverge, marginClarification, LIVE_DISCLOSURE_LOOKAHEAD, liveConsentDisclosure, guidanceForMode, buildFunnelCandidates, routerMode, REFUSAL_INTENT, REFUSAL_GAP, refusalResponse, CONTEXT_SAVE_ORDER_TOOLS, CONTEXT_TOOL_ARG_KEYS, GENERIC_SCHEMA_INTENTS, contextArgsFor, buildContextContinuation, routeQuestionHandler;
 var init_route_question = __esm({
   "../mcp/dist/src/tools/route-question.js"() {
     "use strict";
@@ -57737,8 +59576,12 @@ var init_route_question = __esm({
       }
       return null;
     };
+    isToolNameMention = (token) => {
+      const bare = token.toLowerCase().replace(/^sfi[._]/, "");
+      return getPlaneByTool().has(`sfi.${bare}`);
+    };
     extractEntityQuery = (question, intent) => {
-      const apiReference = question.match(/\b[A-Za-z][A-Za-z0-9_]*(?:\.[A-Za-z][A-Za-z0-9_]*)\b|\b[A-Za-z][A-Za-z0-9_]*__(?:c|mdt|e|x|b|kav)\b|\b[A-Za-z][A-Za-z0-9]*(?:_+[A-Za-z0-9]+)+\b/)?.[0];
+      const apiReference = [...question.matchAll(/\b[A-Za-z][A-Za-z0-9_]*(?:\.[A-Za-z][A-Za-z0-9_]*)\b|\b[A-Za-z][A-Za-z0-9_]*__(?:c|mdt|e|x|b|kav)\b|\b[A-Za-z][A-Za-z0-9]*(?:_+[A-Za-z0-9]+)+\b/g)].map((match) => match[0]).find((token) => !isToolNameMention(token));
       if (apiReference !== void 0) {
         if (intent === "what-if-method-signature" && apiReference.includes(".")) {
           return `${apiReference.slice(0, apiReference.indexOf("."))} class`;
@@ -57750,6 +59593,9 @@ var init_route_question = __esm({
         }
         return apiReference;
       }
+      const quotedTyped = question.match(/['"‘“]([A-Za-z][A-Za-z0-9_ ]{1,40}?)['"’”]\s+(?:field|object|profile|permission\s+set|flow|record\s+type)\b/i)?.[1];
+      if (quotedTyped !== void 0)
+        return quotedTyped.trim();
       const prefixedTypePhrase = question.match(/\b((?:validation\s+rule|permission\s+set|record\s+type|page\s+layout|object|field|flow|class|trigger|layout|profile|report|dashboard)\s+(?:named\s+)?[A-Z][A-Za-z0-9_]*(?:\s+[A-Z][A-Za-z0-9_]*){0,5})\b/)?.[1];
       if (prefixedTypePhrase !== void 0)
         return prefixedTypePhrase.trim();
@@ -57767,6 +59613,15 @@ var init_route_question = __esm({
       const parent = typedMatch?.[2];
       return parent === void 0 ? phrase : `${phrase} on ${parent}`;
     };
+    NAME_IGNORABLE_WORD = /^(?:object|field|flow|class|trigger|page|layout|profile|permission|set|record|type|validation|rule|report|dashboard|logic|named|of|and|or|the|a|an|for)$/i;
+    looksLikeComponentName = (query) => {
+      const words = query.trim().split(/\s+/);
+      if (words.length <= 1)
+        return true;
+      const nameWords = words.filter((word) => !NAME_IGNORABLE_WORD.test(word));
+      return nameWords.length > 0 && nameWords.every((word) => /^["'‘“(]?[A-Z0-9]/.test(word));
+    };
+    extractExistenceProbeToken = (question) => [...question.matchAll(/\b[A-Za-z][A-Za-z0-9_]*__(?:c|mdt|e|x|b|kav)\b|\b[A-Za-z][A-Za-z0-9]*(?:_+[A-Za-z0-9]+)+\b/g)].map((match) => match[0]).find((token) => !isToolNameMention(token) && !/^\d/.test(token)) ?? null;
     inferEntityTypes = (query, intent, question) => {
       if (intent === "what-if-method-signature")
         return ["ApexClass"];
@@ -57891,9 +59746,24 @@ var init_route_question = __esm({
         ]
       };
     };
-    entityAmbiguityRequiresClarification = (query, resolution) => {
+    questionAssertsNameMultiplicity = (question) => /\b(?:a\s+few|several|a\s+couple)\s+of\s+(?:these|those|them)\b|\b(?:two|three|four|five|\d+)\s+different\s+(?:things?|ones?|fields?|objects?|components?|versions?)\b|\bmore\s+than\s+one\s+(?:of\s+(?:these|those|them)|with\s+(?:that|this)\s+name)\b|\bwhich\s+one\s+(?:do|should|did)\s+i\b/i.test(question);
+    entityAmbiguityRequiresClarification = (query, resolution, question, routeTargetsSingleComponentTool = false) => {
+      if (resolution.disposition === "exact" && resolution.candidates.length >= 2 && !/__|\./.test(query)) {
+        const [top2, second2] = resolution.candidates;
+        const sameName = top2 !== void 0 && second2 !== void 0 && top2.matchKind === "exact" && second2.matchKind === "exact" && top2.base === second2.base && top2.apiName.toLowerCase() === second2.apiName.toLowerCase() && top2.parentApiName !== second2.parentApiName;
+        if (sameName) {
+          const promoted = resolveParentQualifier(question ?? "", {
+            ...resolution,
+            disposition: "ambiguous"
+          });
+          if (promoted.disposition === "ambiguous")
+            return true;
+        }
+      }
       if (resolution.disposition !== "ambiguous" || resolution.candidates.length < 2)
         return false;
+      if (question !== void 0 && questionAssertsNameMultiplicity(question))
+        return true;
       const normalized = query.toLowerCase();
       const literalMatches = resolution.candidates.filter((candidate) => candidate.apiName.toLowerCase() === normalized || candidate.id.toLowerCase().endsWith(`:${normalized}`));
       if (literalMatches.length > 1)
@@ -57902,7 +59772,16 @@ var init_route_question = __esm({
         return false;
       const [top, second] = resolution.candidates;
       const looksLikeNamedComponent = (candidate) => candidate.matchKind !== "fuzzy" && (candidate.nameCoverage ?? 1) >= 0.5;
-      return top.base >= 0.92 && second.base >= 0.92 && second.score >= top.score * 0.97 && looksLikeNamedComponent(top) && looksLikeNamedComponent(second);
+      if (top.base >= 0.92 && second.base >= 0.92 && second.score >= top.score * 0.97 && looksLikeNamedComponent(top) && looksLikeNamedComponent(second)) {
+        return true;
+      }
+      if (routeTargetsSingleComponentTool) {
+        const sameName = top.id !== second.id && top.apiName.toLowerCase() === second.apiName.toLowerCase();
+        if (sameName && top.base >= 0.85 && second.base >= 0.85 && second.score >= top.score * 0.8) {
+          return true;
+        }
+      }
+      return false;
     };
     hygienicClarificationOptions = (candidates) => {
       const top = candidates[0];
@@ -57911,6 +59790,21 @@ var init_route_question = __esm({
       const kept = candidates.filter((candidate) => candidate.matchKind !== "fuzzy" && candidate.base >= top.base * 0.9);
       return kept.length > 0 && kept[0] === top ? kept : [top, ...kept.filter((c2) => c2 !== top)];
     };
+    clarificationOptionIds = (candidates) => {
+      const hygienic = hygienicClarificationOptions(candidates.map((candidate) => ({
+        componentId: candidate.id,
+        base: candidate.base,
+        matchKind: candidate.matchKind
+      }))).map((candidate) => candidate.componentId);
+      if (hygienic.length >= 2)
+        return hygienic;
+      const top = candidates[0];
+      if (top === void 0)
+        return hygienic;
+      const topName = top.apiName.toLowerCase();
+      const sameName = candidates.filter((candidate) => candidate.apiName.toLowerCase() === topName).map((candidate) => candidate.id);
+      return sameName.length >= 2 ? sameName : hygienic;
+    };
     splitCompoundQuestion = (question) => {
       const parts = question.split(/(\?|;|\band\s+then\b|\bthen\b|\band\s+(?=who|what|which|how|where|when|why|is|are|can|should|does|do)\b)/i);
       const clauses = [];
@@ -57959,6 +59853,34 @@ var init_route_question = __esm({
     PLAN_FAMILY = /^sfi\.(what_if_|get_impact|safe_to_delete|downstream_effects|tests_for_change|field_lineage)/;
     ASSESSMENT_FAMILY = /(_risk_report$|^sfi\.release_readiness|^sfi\.promotion_readiness|^sfi\.coverage_report|^sfi\.tech_debt_score|^sfi\.governor_limit_risks|^sfi\.crud_fls_audit)/;
     ROUTE_PREAMBLE_TOOLS = /* @__PURE__ */ new Set(["sfi.resolve", "sfi.capabilities"]);
+    SINGLE_COMPONENT_TARGET_TOOLS = /* @__PURE__ */ new Set([
+      "sfi.explain_flow",
+      "sfi.explain_apex_method",
+      "sfi.explain_field",
+      "sfi.explain_formula",
+      "sfi.get_component",
+      "sfi.downstream_effects",
+      "sfi.component_history",
+      "sfi.call_graph",
+      "sfi.method_reachability",
+      "sfi.safe_to_delete_field",
+      "sfi.who_can_run",
+      "sfi.field_360",
+      "sfi.field_lineage",
+      "sfi.what_happens_on_save",
+      "sfi.order_of_execution",
+      "sfi.field_access_audit",
+      "sfi.object_access_audit",
+      "sfi.who_can_access_object",
+      "sfi.what_if_deactivate_flow",
+      "sfi.what_if_disable_trigger"
+    ]);
+    routeTargetsSingleComponent = (route) => {
+      const primary = route.tools.find((tool) => !ROUTE_PREAMBLE_TOOLS.has(tool));
+      if (primary === void 0)
+        return false;
+      return SINGLE_COMPONENT_TARGET_TOOLS.has(primary) || primary.startsWith("sfi.what_if_");
+    };
     TOOL_COMPATIBLE_TYPES = /* @__PURE__ */ new Map([
       ["sfi.call_graph", /* @__PURE__ */ new Set(["ApexClass", "ApexTrigger"])],
       ["sfi.method_reachability", /* @__PURE__ */ new Set(["ApexClass", "ApexTrigger"])],
@@ -58136,6 +60058,12 @@ var init_route_question = __esm({
         return [...cands];
       return [second, top, ...cands.slice(2)];
     };
+    isCompoundPlaneAsk = (question) => {
+      const liveHalf = /\b(?:actually|really)\s+(?:running|firing|executing|live)\b|\bright\s+now\b|\bin\s+production\b/i;
+      const vaultHalf = /\bwhat\s+(?:breaks?|depends|would\s+break|will\s+break)\b|\bwhat\s+does\b[^.?!]{0,60}\bdo\b|\bschema\b|\bmetadata\b|\bsafe\s+to\s+(?:disable|deactivate|delete|remove)\b|\btell\s+me\s+about\b/i;
+      const conjoined = /\b(?:and|also|plus)\b/i;
+      return liveHalf.test(question) && vaultHalf.test(question) && conjoined.test(question);
+    };
     risksDiverge = (a2, b2) => DESTRUCTIVE_TOOL.test(a2.tool) && INFORMATIONAL_IMPACT_TOOL.test(b2.tool) || DESTRUCTIVE_TOOL.test(b2.tool) && INFORMATIONAL_IMPACT_TOOL.test(a2.tool);
     marginClarification = (cands, existingClarification) => {
       if (existingClarification !== null)
@@ -58185,6 +60113,9 @@ var init_route_question = __esm({
     REFUSAL_INTENT = {
       "write-imperative": "refused-write",
       "injection-exfiltration": "refused-injection",
+      "identity-gap": "honest-gap-identity",
+      "forecast-gap": "honest-gap-forecast",
+      "provenance-gap": "honest-gap-provenance",
       "runtime-analytics": "honest-gap-runtime",
       "out-of-scope": "out-of-scope"
     };
@@ -58197,6 +60128,18 @@ var init_route_question = __esm({
         category: "injection",
         note: "prompt-injection/exfiltration shape refused"
       },
+      "identity-gap": {
+        category: "identity-gap",
+        note: "first-person capability ask; no session-user identity \u2014 declined with a which-user clarify pointer"
+      },
+      "forecast-gap": {
+        category: "forecast-gap",
+        note: "future/forecast ask; no time-series or forecasting model \u2014 honest gap, current snapshot offered"
+      },
+      "provenance-gap": {
+        category: "provenance-gap",
+        note: "creator/authorship ask; vault has LastModified, never CreatedBy \u2014 honest gap disclosed"
+      },
       "runtime-analytics": {
         category: "runtime-analytics",
         note: "runtime/ops telemetry the product does not model; honest gap disclosed"
@@ -58470,8 +60413,11 @@ ${renderContextApplied(contextApplied2)}`
         ...entityTypes.length > 0 ? { types: entityTypes } : {}
       }) : null;
       const glossaryAwareEntityResolution = entityQuery !== null && entityResolution?.ok === true ? await applyGlossaryAliases(ctx, entityQuery, entityTypes, entityResolution.value) : null;
-      const refinedEntityResolution = contextExactResolution ?? (entityQuery !== null && glossaryAwareEntityResolution !== null ? resolveParentQualifier(input2.question, refineEntityResolution(entityQuery, glossaryAwareEntityResolution)) : null);
-      const entityClarificationRequired = entityQuery !== null && refinedEntityResolution !== null && entityAmbiguityRequiresClarification(entityQuery, refinedEntityResolution);
+      let refinedEntityResolution = contextExactResolution ?? (entityQuery !== null && glossaryAwareEntityResolution !== null ? resolveParentQualifier(input2.question, refineEntityResolution(entityQuery, glossaryAwareEntityResolution)) : null);
+      const entityClarificationRequired = entityQuery !== null && refinedEntityResolution !== null && // component-type asks ("is X a flow or a trigger?") are EXEMPT: a
+      // same-name cross-type collision is the ANSWER to that question, not an
+      // obstacle — sfi.resolve enumerates the types and the host explains.
+      route.intent !== "component-type" && entityAmbiguityRequiresClarification(entityQuery, refinedEntityResolution, input2.question, routeTargetsSingleComponent(route));
       let entityEvidence = refinedEntityResolution !== null && refinedEntityResolution.disposition !== "none" ? {
         query: entityQuery,
         typeHints: entityTypes,
@@ -58497,9 +60443,10 @@ ${renderContextApplied(contextApplied2)}`
           clarification: {
             required: true,
             question: "Several components match the named entity. Which component did you mean?",
-            // P4 option hygiene: fuzzy grazes and far-below-top rivals are junk,
-            // not options — offer only the plausible candidates.
-            options: hygienicClarificationOptions(entityEvidence?.candidates ?? []).map((candidate) => candidate.componentId)
+            // P4 option hygiene (fuzzy grazes / far-below-top rivals are junk),
+            // with the R4 same-name fallback so a genuine same-name family whose
+            // match reads `fuzzy` (the narrow-clarify shape) still offers ≥2 picks.
+            options: clarificationOptionIds(refinedEntityResolution?.candidates ?? [])
           }
         };
       } else if (entityEvidence?.disposition === "ambiguous" && route.clarification === null) {
@@ -58536,6 +60483,22 @@ ${renderContextApplied(contextApplied2)}`
           route = { ...route, confidence: "low", clarification: marginClar };
         }
       }
+      if (routerMode() === "hybrid" && route.clarification === null && isCompoundPlaneAsk(input2.question)) {
+        const compoundCands = buildFunnelCandidates(route, input2.question, marginRouteToolArgs, input2.mode);
+        const vaultTop = compoundCands.find((candidate) => candidate.plane === "vault");
+        const liveTop = compoundCands.find((candidate) => candidate.plane === "live" || candidate.plane === "hybrid") ?? (/\b(?:running|firing|executing|fired?|ran)\b/i.test(input2.question) ? { tool: "sfi.live_automation_fired" } : void 0);
+        if (vaultTop !== void 0 && liveTop !== void 0) {
+          route = {
+            ...route,
+            confidence: "low",
+            clarification: {
+              required: true,
+              question: `This asks for BOTH a vault-metadata answer AND a live-org verification \u2014 \`${vaultTop.tool}\` answers from the offline vault; \`${liveTop.tool}\` queries the org right now and needs the opt-in live plane. Which should lead? (Pick one; the other can run as a follow-up.)`,
+              options: [vaultTop.tool, liveTop.tool]
+            }
+          };
+        }
+      }
       let premiseFlagged = false;
       if (entityQuery !== null && refinedEntityResolution !== null && refinedEntityResolution.disposition === "none") {
         const bareQuery = entityQuery.replace(/^(?:the|a|an)\s+/i, "").replace(/\s+(?:class(?:es)?|trigger(?:s)?|field(?:s)?|object(?:s)?|flow(?:s)?|component(?:s)?|layout(?:s)?|profile(?:s)?|report(?:s)?|dashboard(?:s)?|rule(?:s)?)$/i, "");
@@ -58544,7 +60507,43 @@ ${renderContextApplied(contextApplied2)}`
           ...entityTypes.length > 0 ? { types: entityTypes } : {}
         }) : null;
         const bareResolution = bareRetry?.ok === true && bareRetry.value.disposition !== "none" ? bareRetry.value : null;
-        if (bareResolution !== null) {
+        let crossTypeResolution = null;
+        if (bareResolution === null && entityTypes.length > 0) {
+          const unscopedQuery = bareQuery.length > 0 ? bareQuery : entityQuery;
+          const unscopedRetry = await resolveComponents(ctx.graph, unscopedQuery, { limit: 5 });
+          if (unscopedRetry.ok && unscopedRetry.value.disposition !== "none" && (unscopedRetry.value.candidates[0]?.base ?? 0) >= 0.9) {
+            crossTypeResolution = unscopedRetry.value;
+          }
+        }
+        if (crossTypeResolution !== null) {
+          const real = crossTypeResolution.candidates[0];
+          const statedTypes = entityTypes.join("/");
+          const typeWarning = `TYPE CHECK: no ${statedTypes} named '${entityQuery}' exists in the vault, but the name matches ${real.id} (a ${real.type}). The question's stated component type appears to be wrong \u2014 answer about the component that actually exists, and say so.`;
+          route = {
+            ...route,
+            confidence: "low",
+            reason: `${route.reason} ${typeWarning}`
+          };
+          refinedEntityResolution = crossTypeResolution;
+          entityEvidence = {
+            query: entityQuery,
+            typeHints: entityTypes,
+            disposition: crossTypeResolution.disposition,
+            clarificationRequired: false,
+            warning: typeWarning,
+            candidates: crossTypeResolution.candidates.slice(0, 5).map((candidate) => ({
+              componentId: candidate.id,
+              type: candidate.type,
+              apiName: candidate.apiName,
+              label: candidate.label,
+              parentApiName: candidate.parentApiName,
+              score: candidate.score,
+              base: candidate.base,
+              matchKind: candidate.matchKind,
+              evidence: candidate.evidence
+            }))
+          };
+        } else if (bareResolution !== null) {
           entityEvidence = {
             query: bareQuery,
             typeHints: entityTypes,
@@ -58563,7 +60562,7 @@ ${renderContextApplied(contextApplied2)}`
               evidence: candidate.evidence
             }))
           };
-        } else {
+        } else if (looksLikeComponentName(entityQuery)) {
           premiseFlagged = true;
           const premiseWarning = `PREMISE CHECK: no component matching '${entityQuery}' exists in the vault \u2014 verify the name (a typo, or metadata newer than the last refresh; /sfi-refresh may help). The routed tool fails closed on an unknown component; do not present its error as an answer about a real component.`;
           route = {
@@ -58579,6 +60578,15 @@ ${renderContextApplied(contextApplied2)}`
             warning: premiseWarning,
             candidates: []
           };
+        } else {
+          entityEvidence = {
+            query: entityQuery,
+            typeHints: entityTypes,
+            disposition: "none",
+            clarificationRequired: false,
+            warning: null,
+            candidates: []
+          };
         }
       } else if (entityQuery !== null && refinedEntityResolution !== null && refinedEntityResolution.disposition === "ambiguous" && (/__(?:c|mdt|e|x|b|kav)\b/i.test(entityQuery) || entityQuery.includes(".")) && !refinedEntityResolution.candidates.some((candidate) => candidate.apiName.toLowerCase() === entityQuery.toLowerCase() || candidate.id.toLowerCase().endsWith(`:${entityQuery.toLowerCase()}`))) {
         premiseFlagged = true;
@@ -58609,11 +60617,78 @@ ${renderContextApplied(contextApplied2)}`
           candidates: []
         };
       }
+      if (!premiseFlagged && entityQuery === null && route.clarification === null && route.intent !== "empty" && route.intent !== "component-lookup") {
+        const probeToken = extractExistenceProbeToken(input2.question);
+        if (probeToken !== null) {
+          const probe = await resolveComponents(ctx.graph, probeToken, { limit: 5 });
+          if (probe.ok) {
+            const lowered = probeToken.toLowerCase();
+            const loose = normLiteral(probeToken);
+            const literalHit = probe.value.candidates.some((candidate) => candidate.apiName.toLowerCase() === lowered || candidate.id.toLowerCase().endsWith(`:${lowered}`) || normLiteral(candidate.apiName) === loose);
+            if (probe.value.disposition === "none" || !literalHit) {
+              premiseFlagged = true;
+              const premiseWarning = `PREMISE CHECK: no component named '${probeToken}' exists in the vault \u2014 any listed candidates are fuzzy lookalikes, not the component you named. Verify the name (a typo, or metadata newer than the last refresh; /sfi-refresh may help). The routed tool fails closed on an unknown component; do not present its error as an answer about a real component.`;
+              route = {
+                ...route,
+                confidence: "low",
+                reason: `${route.reason} ${premiseWarning}`
+              };
+              entityEvidence = {
+                query: probeToken,
+                typeHints: [],
+                disposition: "none",
+                clarificationRequired: false,
+                warning: premiseWarning,
+                candidates: probe.value.candidates.slice(0, 5).map((candidate) => ({
+                  componentId: candidate.id,
+                  type: candidate.type,
+                  apiName: candidate.apiName,
+                  label: candidate.label,
+                  parentApiName: candidate.parentApiName,
+                  score: candidate.score,
+                  base: candidate.base,
+                  matchKind: candidate.matchKind,
+                  evidence: candidate.evidence
+                }))
+              };
+            }
+          }
+        }
+      }
       let contextRouteApplied = null;
       if (validatedContext !== null && route.clarification === null && !premiseFlagged) {
         const previous = validatedContext.previous;
         const stillUnrouted = route.intent === "unrouted" && route.plane === "unknown";
-        const reparamAnchor = detectReparamAnchor(input2.question);
+        const gapFollowUpFamily = stillUnrouted ? detectGapShapedFollowUp(input2.question) : null;
+        if (gapFollowUpFamily !== null) {
+          const gapDescription = {
+            judgment: "a normative judgment (should/normal/risky) \u2014 sf-intelligence reads org metadata and has no opinion to offer",
+            delivery: "file export or message delivery, which the product does not perform",
+            "tool-self-capability": "the product's own capability boundary \u2014 sfi.capabilities answers what is and is not built",
+            "deployment-status": "deployment/pending-change status, runtime telemetry the vault does not model",
+            "runtime-analytics": "runtime org data (login history, API-call logs, approval-instance history, record field-history, subscription recipients, chatter posts, sandbox-refresh/deployment logs, or execution traces) \u2014 this is live runtime telemetry, not vault metadata"
+          };
+          const carried = previous.componentId !== void 0 ? ` The component carried from the previous turn (${previous.componentId}) was noted but the previous tool was NOT inherited \u2014 inheriting it would execute a read that cannot answer this ask.` : "";
+          route = {
+            question: input2.question,
+            plane: "unknown",
+            intent: "context-gap-followup",
+            tools: [],
+            liveRequired: false,
+            needsResolve: false,
+            reason: `HONEST GAP (context follow-up): this follow-up asks for ${gapDescription[gapFollowUpFamily] ?? gapFollowUpFamily}.${carried}`,
+            gap: {
+              category: "context-gap-followup",
+              note: `gap-shaped follow-up (${gapFollowUpFamily}); context continuation suppressed rather than inheriting the previous tool`
+            },
+            confidence: "high",
+            risk: "informational",
+            alternatives: [],
+            clarification: null,
+            plan: []
+          };
+        }
+        const reparamAnchor = gapFollowUpFamily !== null ? null : detectReparamAnchor(input2.question);
         const ownRouteWeak = stillUnrouted || GENERIC_SCHEMA_INTENTS.has(route.intent) && route.confidence !== "high";
         if (reparamAnchor !== null && ownRouteWeak && previous.tool !== void 0) {
           let target = contextSubstitution === null && refinedEntityResolution?.disposition === "exact" ? refinedEntityResolution.candidates[0] : null;
@@ -58626,7 +60701,14 @@ ${renderContextApplied(contextApplied2)}`
                 const refinedTarget = refineEntityResolution(phrase, resolvedTarget.value);
                 if (refinedTarget.disposition === "exact") {
                   target = refinedTarget.candidates[0];
-                } else if (refinedTarget.disposition === "ambiguous" && entityAmbiguityRequiresClarification(phrase, refinedTarget)) {
+                } else if (refinedTarget.disposition === "ambiguous" && entityAmbiguityRequiresClarification(
+                  phrase,
+                  refinedTarget,
+                  void 0,
+                  // The re-parameterization inherits previous.tool; the widened
+                  // R4 band applies when THAT tool is single-component-target.
+                  previous.tool !== void 0 && (SINGLE_COMPONENT_TARGET_TOOLS.has(previous.tool) || previous.tool.startsWith("sfi.what_if_"))
+                )) {
                   route = {
                     ...route,
                     confidence: "low",
@@ -58677,7 +60759,9 @@ ${renderContextApplied(contextApplied2)}`
         }
       }
       let advisoryCandidates = null;
-      if (route.intent === "unrouted" && route.plane === "unknown" && route.clarification === null && !premiseFlagged) {
+      const questionHead = input2.question.trim().split(/\s+/).slice(0, 5).join(" ");
+      const anaphorOnlyFragment = validatedContext === null && detectPronounAnchor(questionHead) !== null && (entityQuery === null || isAnaphorOnly(entityQuery));
+      if (route.intent === "unrouted" && route.plane === "unknown" && route.clarification === null && !premiseFlagged && !anaphorOnlyFragment) {
         const cands = buildFunnelCandidates(route, input2.question, marginRouteToolArgs, input2.mode);
         advisoryCandidates = cands;
         const resolvedExact = refinedEntityResolution?.disposition === "exact" ? refinedEntityResolution.candidates[0] : void 0;
@@ -67374,7 +69458,7 @@ __export(tools_exports, {
   toolProfile: () => toolProfile
 });
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-var SEARCH_COMPONENTS_INPUT_SCHEMA, CAPABILITIES_INPUT_SCHEMA, SYNTHESIZE_ANSWER_INPUT_SCHEMA, ORG_PULSE_INPUT_SCHEMA, ORG_CARD_INPUT_SCHEMA, LIST_ANALYSES_INPUT_SCHEMA, DESCRIBE_ANALYSIS_INPUT_SCHEMA, RUN_ANALYSIS_INPUT_SCHEMA, FLEET_FIND_INPUT_SCHEMA, FLEET_DRIFT_RANKING_INPUT_SCHEMA, RESOLVE_INPUT_SCHEMA, GET_COMPONENT_INPUT_SCHEMA, GET_EDGES_INPUT_SCHEMA, LIST_COMPONENTS_INPUT_SCHEMA, GET_SUBGRAPH_INPUT_SCHEMA, SEARCH_APEX_SOURCE_INPUT_SCHEMA, SEARCH_FLOW_METADATA_INPUT_SCHEMA, NAMING_CONVENTION_REPORT_INPUT_SCHEMA, GET_MANIFEST_INPUT_SCHEMA, COVERAGE_REPORT_INPUT_SCHEMA, RETRIEVE_BLINDSPOT_REPORT_INPUT_SCHEMA, BASELINE_ACKNOWLEDGE_INPUT_SCHEMA, BASELINE_STATUS_INPUT_SCHEMA, TREND_INPUT_SCHEMA, CHURN_INPUT_SCHEMA, LIVE_ENABLED_PROPERTY, LIVE_DESCRIBE_INPUT_SCHEMA, LIVE_COUNT_INPUT_SCHEMA, LIVE_STALE_CHECK_INPUT_SCHEMA, LIVE_SAMPLE_INPUT_SCHEMA, LIVE_FIELD_POPULATION_INPUT_SCHEMA, LIVE_ORG_LIMITS_INPUT_SCHEMA, LIVE_PICKLIST_USAGE_INPUT_SCHEMA, LIVE_AUTOMATION_FIRED_INPUT_SCHEMA, LIVE_INACTIVE_USERS_INPUT_SCHEMA, LIVE_LICENSE_USAGE_INPUT_SCHEMA, LIVE_GROUP_COUNT_INPUT_SCHEMA, LIVE_STALE_RECORDS_INPUT_SCHEMA, LIVE_RECENT_ACTIVITY_INPUT_SCHEMA, LIVE_AGGREGATE_INPUT_SCHEMA, LIVE_DUPLICATE_CHECK_INPUT_SCHEMA, LIVE_OWNER_BREAKDOWN_INPUT_SCHEMA, LIVE_STORAGE_BY_OBJECT_INPUT_SCHEMA, LIVE_REPORT_USAGE_INPUT_SCHEMA, LIVE_FOLDER_ACCESS_INPUT_SCHEMA, LIVE_EMAIL_TEMPLATE_USAGE_INPUT_SCHEMA, LIVE_ORG_HEALTH_INPUT_SCHEMA, LIVE_CONSENT_INPUT_SCHEMA, ROUTE_QUESTION_INPUT_SCHEMA, SYNTHESIS_INPUT_SCHEMA, PERMISSION_RISK_REPORT_INPUT_SCHEMA, HEALTH_CHECK_INPUT_SCHEMA, GET_IMPACT_INPUT_SCHEMA, BLAST_RADIUS_LIVE_INPUT_SCHEMA, FIND_FORMULA_REFERENCES_INPUT_SCHEMA, FIND_APEX_USAGES_INPUT_SCHEMA, FIND_CODE_USAGES_INPUT_SCHEMA, EFFECTIVE_PERMISSIONS_INPUT_SCHEMA, LIST_VIEW_SHARING_INPUT_SCHEMA, WHO_CAN_RUN_INPUT_SCHEMA, WHO_CAN_ACCESS_OBJECT_INPUT_SCHEMA, WHY_CANT_USER_SEE_RECORD_INPUT_SCHEMA, LAYOUT_FOR_USER_INPUT_SCHEMA, LAYOUT_ASSIGNMENTS_INPUT_SCHEMA, USER_ABILITY_INPUT_SCHEMA, PROFILE_SECURITY_INPUT_SCHEMA, LIGHTNING_PAGES_INPUT_SCHEMA, APP_ACCESS_INPUT_SCHEMA, TAB_AVAILABILITY_INPUT_SCHEMA, LIFECYCLE_PROCESS_INPUT_SCHEMA, INTEGRATION_MAP_INPUT_SCHEMA, EVENT_SUBSCRIBERS_INPUT_SCHEMA, LOOKUP_RECORD_INPUT_SCHEMA, GUIDANCE_INPUT_SCHEMA, EXPLAIN_FIELD_INPUT_SCHEMA, SAFE_TO_DELETE_FIELD_INPUT_SCHEMA, UNUSED_COMPONENTS_INPUT_SCHEMA, DIFF_SNAPSHOTS_INPUT_SCHEMA, COMPARE_COMPONENTS_INPUT_SCHEMA, PII_INVENTORY_INPUT_SCHEMA, FIELD_ACCESS_AUDIT_INPUT_SCHEMA, OBJECT_ACCESS_AUDIT_INPUT_SCHEMA, RECORDTYPE_AVAILABILITY_INPUT_SCHEMA, FIELD_360_INPUT_SCHEMA, FIELD_LINEAGE_INPUT_SCHEMA, ORG_OVERVIEW_INPUT_SCHEMA, DOMAIN_CLUSTERS_INPUT_SCHEMA, CHANGED_SINCE_INPUT_SCHEMA, LAST_MODIFIED_INPUT_SCHEMA, WHAT_HAPPENS_ON_SAVE_INPUT_SCHEMA, WHY_FIELD_CHANGED_INPUT_SCHEMA, ORDER_OF_EXECUTION_INPUT_SCHEMA, EXPLAIN_FLOW_INPUT_SCHEMA, EXPLAIN_APEX_METHOD_INPUT_SCHEMA, EXPLAIN_FORMULA_INPUT_SCHEMA, EXPORT_MANIFEST_INPUT_SCHEMA, UNUSED_FIELDS_DEEP_INPUT_SCHEMA, FIELD_CLEANUP_CANDIDATES_INPUT_SCHEMA, PROCESS_BUILDER_MIGRATION_CANDIDATES_INPUT_SCHEMA, UNASSIGNED_PERMISSION_SETS_INPUT_SCHEMA, INSTALLED_PACKAGE_CATALOG_INPUT_SCHEMA, ANNOTATIONS_INPUT_SCHEMA, PROPOSE_ANNOTATION_INPUT_SCHEMA, COMPONENT_HISTORY_INPUT_SCHEMA, COMPONENT_AS_OF_INPUT_SCHEMA, FIND_COMPONENT_USAGES_INPUT_SCHEMA, EMPTY_QUEUES_AND_GROUPS_INPUT_SCHEMA, TECH_DEBT_SCORE_INPUT_SCHEMA, CODE_QUALITY_AUDIT_INPUT_SCHEMA, GOVERNOR_LIMIT_RISKS_INPUT_SCHEMA, FIND_HARDCODED_VALUES_INPUT_SCHEMA, CRUD_FLS_AUDIT_INPUT_SCHEMA, TEST_COVERAGE_GAPS_INPUT_SCHEMA, WHAT_IF_CHANGE_FIELD_VALUE_INPUT_SCHEMA, VALUE_CHANGE_AUDIT_INPUT_SCHEMA, WHAT_IF_CHANGE_FIELD_TYPE_INPUT_SCHEMA, WHAT_IF_REMOVE_PICKLIST_VALUE_INPUT_SCHEMA, WHAT_IF_MAKE_FIELD_REQUIRED_INPUT_SCHEMA, WHAT_IF_DEACTIVATE_FLOW_INPUT_SCHEMA, WHAT_IF_DISABLE_TRIGGER_INPUT_SCHEMA, WHAT_IF_CHANGE_METHOD_SIGNATURE_INPUT_SCHEMA, WHAT_IF_MERGE_PROFILES_INPUT_SCHEMA, WHAT_IF_SPLIT_PROFILE_INPUT_SCHEMA, GENERATE_DATA_DICTIONARY_INPUT_SCHEMA, GENERATE_ADMIN_HANDBOOK_INPUT_SCHEMA, GENERATE_ARCHITECTURE_OVERVIEW_INPUT_SCHEMA, GENERATE_SHARING_SUMMARY_INPUT_SCHEMA, GENERATE_COMPLIANCE_REPORT_INPUT_SCHEMA, GENERATE_ONBOARDING_DOC_INPUT_SCHEMA, CALL_GRAPH_INPUT_SCHEMA, DOWNSTREAM_EFFECTS_INPUT_SCHEMA, TEST_COVERAGE_FOR_METHOD_INPUT_SCHEMA, MEANINGFUL_TEST_AUDIT_INPUT_SCHEMA, METHOD_REACHABILITY_INPUT_SCHEMA, TESTS_FOR_CHANGE_INPUT_SCHEMA, PACKAGE_IMPACT_INPUT_SCHEMA, CDC_SUBSCRIBERS_INPUT_SCHEMA, ASYNC_CHAIN_DEPTH_INPUT_SCHEMA, SCHEDULED_JOB_CATALOG_INPUT_SCHEMA, OUTBOUND_MESSAGE_CATALOG_INPUT_SCHEMA, ENDPOINT_CATALOG_INPUT_SCHEMA, FIELD_MEANING_INPUT_SCHEMA, DISAMBIGUATE_CONCEPTS_INPUT_SCHEMA, FIELD_PROVENANCE_INPUT_SCHEMA, FIND_FIELD_ANYWHERE_INPUT_SCHEMA, FIND_SEMANTIC_FIELD_INPUT_SCHEMA, FIND_HARDCODED_VALUES_ANYWHERE_INPUT_SCHEMA, FIND_CLONE_PATTERNS_INPUT_SCHEMA, FIND_DEAD_CODE_INPUT_SCHEMA, CPQ_RULE_CHAIN_INPUT_SCHEMA, CPQ_QUOTE_TEMPLATE_BREAKDOWN_INPUT_SCHEMA, CPQ_DEPENDENCY_MAP_INPUT_SCHEMA, COMPARE_VAULTS_INPUT_SCHEMA, PROMOTION_READINESS_INPUT_SCHEMA, COMPARE_OBJECT_ACROSS_VAULTS_INPUT_SCHEMA, COMPARE_PROFILE_ACROSS_VAULTS_INPUT_SCHEMA, FIELD_MAPPING_BETWEEN_OBJECTS_INPUT_SCHEMA, INTEGRATION_PROCEDURE_CHAIN_INPUT_SCHEMA, OMNISCRIPT_FLOW_INPUT_SCHEMA, OMNIUICARD_WIDGET_BREAKDOWN_INPUT_SCHEMA, DATATRANSFORM_FIELD_MAP_INPUT_SCHEMA, DECISION_TABLE_BROWSE_INPUT_SCHEMA, FIND_DEPENDENCY_CYCLES_INPUT_SCHEMA, APEX_TEST_COVERAGE_INPUT_SCHEMA, AUTOMATION_BUILD_ADVISOR_INPUT_SCHEMA, APEX_BUILD_ADVISOR_INPUT_SCHEMA, FIELD_CHANGE_ADVISOR_INPUT_SCHEMA, LIVE_DRIFT_CHECK_INPUT_SCHEMA, ORG_HISTORY_INPUT_SCHEMA, WHAT_CHANGED_SINCE_REFRESH_INPUT_SCHEMA, V01_TOOLS, KNOWN_TOOL_NAMES, dispatchTool, runTool, advertisedTools, registerTools, MAX_RESPONSE_BYTES, RESPONSE_BUDGET_DEFAULT_BYTES, responseBudgetBytes, SLIM_STRING_THRESHOLD_BYTES2, SLIM_STRING_KEEP_CHARS2, TRUNCATE_KEEP_MIN, utf8Bytes2, truncateDataArrays, slimDataStrings, jsonResult, NARROWING_KNOB_RE, narrowingKnobs;
+var SEARCH_COMPONENTS_INPUT_SCHEMA, CAPABILITIES_INPUT_SCHEMA, SYNTHESIZE_ANSWER_INPUT_SCHEMA, ORG_PULSE_INPUT_SCHEMA, ORG_CARD_INPUT_SCHEMA, LIST_ANALYSES_INPUT_SCHEMA, DESCRIBE_ANALYSIS_INPUT_SCHEMA, RUN_ANALYSIS_INPUT_SCHEMA, FLEET_FIND_INPUT_SCHEMA, FLEET_DRIFT_RANKING_INPUT_SCHEMA, RESOLVE_INPUT_SCHEMA, GET_COMPONENT_INPUT_SCHEMA, GET_EDGES_INPUT_SCHEMA, LIST_COMPONENTS_INPUT_SCHEMA, GET_SUBGRAPH_INPUT_SCHEMA, SEARCH_APEX_SOURCE_INPUT_SCHEMA, SEARCH_FLOW_METADATA_INPUT_SCHEMA, NAMING_CONVENTION_REPORT_INPUT_SCHEMA, GET_MANIFEST_INPUT_SCHEMA, COVERAGE_REPORT_INPUT_SCHEMA, RETRIEVE_BLINDSPOT_REPORT_INPUT_SCHEMA, BASELINE_ACKNOWLEDGE_INPUT_SCHEMA, BASELINE_STATUS_INPUT_SCHEMA, TREND_INPUT_SCHEMA, CHURN_INPUT_SCHEMA, LIVE_ENABLED_PROPERTY, LIVE_DESCRIBE_INPUT_SCHEMA, LIVE_COUNT_INPUT_SCHEMA, LIVE_STALE_CHECK_INPUT_SCHEMA, LIVE_SAMPLE_INPUT_SCHEMA, LIVE_FIELD_POPULATION_INPUT_SCHEMA, LIVE_ORG_LIMITS_INPUT_SCHEMA, LIVE_PICKLIST_USAGE_INPUT_SCHEMA, LIVE_AUTOMATION_FIRED_INPUT_SCHEMA, LIVE_INACTIVE_USERS_INPUT_SCHEMA, LIVE_PERMSET_HOLDERS_INPUT_SCHEMA, LIVE_ZOMBIE_ACCOUNTS_INPUT_SCHEMA, LIVE_GROUP_MEMBERS_INPUT_SCHEMA, LIVE_USER_PERMSETS_INPUT_SCHEMA, LIVE_LICENSE_USAGE_INPUT_SCHEMA, LIVE_GROUP_COUNT_INPUT_SCHEMA, LIVE_STALE_RECORDS_INPUT_SCHEMA, LIVE_RECENT_ACTIVITY_INPUT_SCHEMA, LIVE_AGGREGATE_INPUT_SCHEMA, LIVE_DUPLICATE_CHECK_INPUT_SCHEMA, LIVE_OWNER_BREAKDOWN_INPUT_SCHEMA, LIVE_STORAGE_BY_OBJECT_INPUT_SCHEMA, LIVE_REPORT_USAGE_INPUT_SCHEMA, LIVE_FOLDER_ACCESS_INPUT_SCHEMA, LIVE_EMAIL_TEMPLATE_USAGE_INPUT_SCHEMA, LIVE_ORG_HEALTH_INPUT_SCHEMA, LIVE_CONSENT_INPUT_SCHEMA, ROUTE_QUESTION_INPUT_SCHEMA, SYNTHESIS_INPUT_SCHEMA, PERMISSION_RISK_REPORT_INPUT_SCHEMA, HEALTH_CHECK_INPUT_SCHEMA, GET_IMPACT_INPUT_SCHEMA, BLAST_RADIUS_LIVE_INPUT_SCHEMA, FIND_FORMULA_REFERENCES_INPUT_SCHEMA, FIND_APEX_USAGES_INPUT_SCHEMA, FIND_CODE_USAGES_INPUT_SCHEMA, EFFECTIVE_PERMISSIONS_INPUT_SCHEMA, LIST_VIEW_SHARING_INPUT_SCHEMA, WHO_CAN_RUN_INPUT_SCHEMA, WHO_CAN_ACCESS_OBJECT_INPUT_SCHEMA, WHY_CANT_USER_SEE_RECORD_INPUT_SCHEMA, LAYOUT_FOR_USER_INPUT_SCHEMA, LAYOUT_ASSIGNMENTS_INPUT_SCHEMA, USER_ABILITY_INPUT_SCHEMA, PROFILE_SECURITY_INPUT_SCHEMA, LIGHTNING_PAGES_INPUT_SCHEMA, APP_ACCESS_INPUT_SCHEMA, TAB_AVAILABILITY_INPUT_SCHEMA, LIFECYCLE_PROCESS_INPUT_SCHEMA, INTEGRATION_MAP_INPUT_SCHEMA, EVENT_SUBSCRIBERS_INPUT_SCHEMA, LOOKUP_RECORD_INPUT_SCHEMA, GUIDANCE_INPUT_SCHEMA, EXPLAIN_FIELD_INPUT_SCHEMA, SAFE_TO_DELETE_FIELD_INPUT_SCHEMA, UNUSED_COMPONENTS_INPUT_SCHEMA, DIFF_SNAPSHOTS_INPUT_SCHEMA, COMPARE_COMPONENTS_INPUT_SCHEMA, PII_INVENTORY_INPUT_SCHEMA, FIELD_ACCESS_AUDIT_INPUT_SCHEMA, OBJECT_ACCESS_AUDIT_INPUT_SCHEMA, RECORDTYPE_AVAILABILITY_INPUT_SCHEMA, FIELD_360_INPUT_SCHEMA, FIELD_LINEAGE_INPUT_SCHEMA, ORG_OVERVIEW_INPUT_SCHEMA, DOMAIN_CLUSTERS_INPUT_SCHEMA, CHANGED_SINCE_INPUT_SCHEMA, LAST_MODIFIED_INPUT_SCHEMA, WHAT_HAPPENS_ON_SAVE_INPUT_SCHEMA, WHY_FIELD_CHANGED_INPUT_SCHEMA, ORDER_OF_EXECUTION_INPUT_SCHEMA, EXPLAIN_FLOW_INPUT_SCHEMA, EXPLAIN_APEX_METHOD_INPUT_SCHEMA, EXPLAIN_FORMULA_INPUT_SCHEMA, EXPORT_MANIFEST_INPUT_SCHEMA, UNUSED_FIELDS_DEEP_INPUT_SCHEMA, FIELD_CLEANUP_CANDIDATES_INPUT_SCHEMA, PROCESS_BUILDER_MIGRATION_CANDIDATES_INPUT_SCHEMA, UNASSIGNED_PERMISSION_SETS_INPUT_SCHEMA, INSTALLED_PACKAGE_CATALOG_INPUT_SCHEMA, ANNOTATIONS_INPUT_SCHEMA, PROPOSE_ANNOTATION_INPUT_SCHEMA, COMPONENT_HISTORY_INPUT_SCHEMA, COMPONENT_AS_OF_INPUT_SCHEMA, FIND_COMPONENT_USAGES_INPUT_SCHEMA, EMPTY_QUEUES_AND_GROUPS_INPUT_SCHEMA, TECH_DEBT_SCORE_INPUT_SCHEMA, CODE_QUALITY_AUDIT_INPUT_SCHEMA, GOVERNOR_LIMIT_RISKS_INPUT_SCHEMA, FIND_HARDCODED_VALUES_INPUT_SCHEMA, CRUD_FLS_AUDIT_INPUT_SCHEMA, TEST_COVERAGE_GAPS_INPUT_SCHEMA, WHAT_IF_CHANGE_FIELD_VALUE_INPUT_SCHEMA, VALUE_CHANGE_AUDIT_INPUT_SCHEMA, WHAT_IF_CHANGE_FIELD_TYPE_INPUT_SCHEMA, WHAT_IF_REMOVE_PICKLIST_VALUE_INPUT_SCHEMA, WHAT_IF_MAKE_FIELD_REQUIRED_INPUT_SCHEMA, WHAT_IF_DEACTIVATE_FLOW_INPUT_SCHEMA, WHAT_IF_DISABLE_TRIGGER_INPUT_SCHEMA, WHAT_IF_CHANGE_METHOD_SIGNATURE_INPUT_SCHEMA, WHAT_IF_MERGE_PROFILES_INPUT_SCHEMA, WHAT_IF_SPLIT_PROFILE_INPUT_SCHEMA, GENERATE_DATA_DICTIONARY_INPUT_SCHEMA, GENERATE_ADMIN_HANDBOOK_INPUT_SCHEMA, GENERATE_ARCHITECTURE_OVERVIEW_INPUT_SCHEMA, GENERATE_SHARING_SUMMARY_INPUT_SCHEMA, GENERATE_COMPLIANCE_REPORT_INPUT_SCHEMA, GENERATE_ONBOARDING_DOC_INPUT_SCHEMA, CALL_GRAPH_INPUT_SCHEMA, DOWNSTREAM_EFFECTS_INPUT_SCHEMA, TEST_COVERAGE_FOR_METHOD_INPUT_SCHEMA, MEANINGFUL_TEST_AUDIT_INPUT_SCHEMA, METHOD_REACHABILITY_INPUT_SCHEMA, TESTS_FOR_CHANGE_INPUT_SCHEMA, PACKAGE_IMPACT_INPUT_SCHEMA, CDC_SUBSCRIBERS_INPUT_SCHEMA, ASYNC_CHAIN_DEPTH_INPUT_SCHEMA, SCHEDULED_JOB_CATALOG_INPUT_SCHEMA, OUTBOUND_MESSAGE_CATALOG_INPUT_SCHEMA, ENDPOINT_CATALOG_INPUT_SCHEMA, FIELD_MEANING_INPUT_SCHEMA, DISAMBIGUATE_CONCEPTS_INPUT_SCHEMA, FIELD_PROVENANCE_INPUT_SCHEMA, FIND_FIELD_ANYWHERE_INPUT_SCHEMA, FIND_SEMANTIC_FIELD_INPUT_SCHEMA, FIND_HARDCODED_VALUES_ANYWHERE_INPUT_SCHEMA, FIND_CLONE_PATTERNS_INPUT_SCHEMA, FIND_DEAD_CODE_INPUT_SCHEMA, CPQ_RULE_CHAIN_INPUT_SCHEMA, CPQ_QUOTE_TEMPLATE_BREAKDOWN_INPUT_SCHEMA, CPQ_DEPENDENCY_MAP_INPUT_SCHEMA, COMPARE_VAULTS_INPUT_SCHEMA, PROMOTION_READINESS_INPUT_SCHEMA, COMPARE_OBJECT_ACROSS_VAULTS_INPUT_SCHEMA, COMPARE_PROFILE_ACROSS_VAULTS_INPUT_SCHEMA, FIELD_MAPPING_BETWEEN_OBJECTS_INPUT_SCHEMA, INTEGRATION_PROCEDURE_CHAIN_INPUT_SCHEMA, OMNISCRIPT_FLOW_INPUT_SCHEMA, OMNIUICARD_WIDGET_BREAKDOWN_INPUT_SCHEMA, DATATRANSFORM_FIELD_MAP_INPUT_SCHEMA, DECISION_TABLE_BROWSE_INPUT_SCHEMA, FIND_DEPENDENCY_CYCLES_INPUT_SCHEMA, APEX_TEST_COVERAGE_INPUT_SCHEMA, AUTOMATION_BUILD_ADVISOR_INPUT_SCHEMA, APEX_BUILD_ADVISOR_INPUT_SCHEMA, FIELD_CHANGE_ADVISOR_INPUT_SCHEMA, LIVE_DRIFT_CHECK_INPUT_SCHEMA, ORG_HISTORY_INPUT_SCHEMA, WHAT_CHANGED_SINCE_REFRESH_INPUT_SCHEMA, V01_TOOLS, KNOWN_TOOL_NAMES, dispatchTool, runTool, advertisedTools, registerTools, MAX_RESPONSE_BYTES, RESPONSE_BUDGET_DEFAULT_BYTES, responseBudgetBytes, SLIM_STRING_THRESHOLD_BYTES2, SLIM_STRING_KEEP_CHARS2, TRUNCATE_KEEP_MIN, utf8Bytes2, truncateDataArrays, slimDataStrings, jsonResult, NARROWING_KNOB_RE, narrowingKnobs;
 var init_tools = __esm({
   "../mcp/dist/src/tools/index.js"() {
     "use strict";
@@ -67913,6 +69997,83 @@ var init_tools = __esm({
         ...LIVE_ENABLED_PROPERTY
       }
     });
+    LIVE_PERMSET_HOLDERS_INPUT_SCHEMA = Object.freeze({
+      type: "object",
+      required: ["name"],
+      properties: {
+        name: {
+          type: "string",
+          minLength: 1,
+          description: "Exact PermissionSet.Name / PermissionSetGroup DeveloperName / Profile.Name (labels accepted)."
+        },
+        kind: {
+          type: "string",
+          enum: ["permissionSet", "permissionSetGroup", "profile", "auto"],
+          description: "What `name` names. Default 'auto' probes PermissionSet \u2192 PermissionSetGroup \u2192 Profile by exact name/label; no-match or ambiguity errors honestly."
+        },
+        includeInactiveAssignees: { type: "boolean" },
+        includeViaGroups: {
+          type: "boolean",
+          description: "For kind permissionSet: also count holders receiving the set through a PermissionSetGroup containing it (default true)."
+        },
+        groupBy: { type: "string", enum: ["none", "profile"] },
+        limit: { type: "integer", minimum: 1, maximum: 500 },
+        afterId: {
+          type: "string",
+          description: "Keyset paging token \u2014 the `nextAfterId` from the previous page."
+        },
+        ...LIVE_ENABLED_PROPERTY
+      }
+    });
+    LIVE_ZOMBIE_ACCOUNTS_INPUT_SCHEMA = Object.freeze({
+      type: "object",
+      properties: {
+        minDaysInactive: {
+          type: "integer",
+          minimum: 0,
+          maximum: 3650,
+          description: "Additionally require last login older than N days (default 0 = ignore login age)."
+        },
+        includeAllUserTypes: { type: "boolean" },
+        limit: { type: "integer", minimum: 1, maximum: 500 },
+        ...LIVE_ENABLED_PROPERTY
+      }
+    });
+    LIVE_GROUP_MEMBERS_INPUT_SCHEMA = Object.freeze({
+      type: "object",
+      required: ["name"],
+      properties: {
+        name: {
+          type: "string",
+          minLength: 1,
+          description: "Exact Group DeveloperName or Name (label) of the queue / public group."
+        },
+        groupType: {
+          type: "string",
+          enum: ["Queue", "Regular", "auto"],
+          description: "What kind of Group `name` names. Default 'auto' matches both; an ambiguous name across both errors honestly."
+        },
+        expandNested: {
+          type: "boolean",
+          description: "Expand exactly ONE level of nested public groups (default false). Role entries are never expanded."
+        },
+        limit: { type: "integer", minimum: 1, maximum: 500 },
+        ...LIVE_ENABLED_PROPERTY
+      }
+    });
+    LIVE_USER_PERMSETS_INPUT_SCHEMA = Object.freeze({
+      type: "object",
+      required: ["user"],
+      properties: {
+        user: {
+          type: "string",
+          minLength: 1,
+          description: "Exact Username (preferred \u2014 unique) or exact User.Name. An ambiguous name returns candidates, never a guess."
+        },
+        limit: { type: "integer", minimum: 1, maximum: 500 },
+        ...LIVE_ENABLED_PROPERTY
+      }
+    });
     LIVE_LICENSE_USAGE_INPUT_SCHEMA = Object.freeze({
       type: "object",
       properties: {
@@ -69572,7 +71733,7 @@ var init_tools = __esm({
       },
       {
         name: "sfi.coverage_report",
-        description: "Report the vault's self-assessed metadata coverage: covered, partial, not-modeled, and \u2014 during a staged refresh \u2014 pending families (queued by the in-progress tiered build, with `stagedBuild` tier progress; pending types count as missing coverage, so absence answers about them must stay qualified). Use before absence-based or destructive answers.",
+        description: "Report the vault's self-assessed metadata coverage: covered, partial, not-modeled, and \u2014 during a staged refresh \u2014 pending families (queued by the in-progress tiered build, with `stagedBuild` tier progress; pending types count as missing coverage, so absence answers about them must stay qualified). Use before absence-based or destructive answers. The `assignmentData` section covers runtime assignment data (User / PermissionSetAssignment / GroupMember): NOT in the vault by design (a runtime data object, not a retrieve gap) \u2014 it names the consent-gated live tools that answer those questions (sfi.live_permset_holders, sfi.live_user_permsets, sfi.live_group_members, sfi.live_zombie_accounts), whether live consent is currently granted, and whether/when a counts-only facts snapshot (`sfi refresh --with-data-shape`) was captured.",
         inputSchema: COVERAGE_REPORT_INPUT_SCHEMA
       },
       {
@@ -69582,7 +71743,7 @@ var init_tools = __esm({
       },
       {
         name: "sfi.health_check",
-        description: 'Report self-assessed server health, render consistency, and coverage completeness, plus a freshness block (vault age, a stale flag, the most recent refresh\'s change count, and a yellow-flag nudge when the vault is old or local source drifted). While a staged refresh (`sfi refresh --staged`) is mid-build, status is degraded with explicit tier progress ("building tier i/n") until the final tier clears the marker.',
+        description: 'Report self-assessed server health, render consistency, and coverage completeness, plus a freshness block (vault age, a stale flag, the most recent refresh\'s change count, and a yellow-flag nudge when the vault is old or local source drifted). While a staged refresh (`sfi refresh --staged`) is mid-build, status is degraded with explicit tier progress ("building tier i/n") until the final tier clears the marker. Also carries an INFORMATIONAL `assignmentData` block (runtime assignment data is live-first by design \u2014 its absence never degrades status; a stale counts snapshot >30 days old earns an advisory only).',
         inputSchema: HEALTH_CHECK_INPUT_SCHEMA
       },
       {
@@ -69662,9 +71823,29 @@ var init_tools = __esm({
       },
       {
         name: "sfi.live_inactive_users",
-        description: "Opt-in live org: active users who haven't logged in within N days (default 30) or never have \u2014 the license-reclamation / dormant-account question. Standard (human) users by default; reports the true total (`totalInactive`) plus a capped detail page, oldest-dormant first. `limit` pages the detail rows (default 100, hard cap 500) and a per-response ~36 KB byte budget trims the page further when a wide page would exceed it (the response carries both the structured rows and a rendered table, so it can't trip the global ~45 KB limit); `capped` flips true when more remain and a `note` appears when the page was byte-trimmed. Read-only; LastLoginDate is live-only state.",
+        description: "Opt-in live org: active users who haven't logged in within N days (default 30) or never have \u2014 the license-reclamation / dormant-account question. Standard (human) users by default; reports the true total (`totalInactive`) plus a capped detail page, oldest-dormant first. `limit` pages the detail rows (default 100, hard cap 500) and a per-response ~36 KB byte budget trims the page further when a wide page would exceed it (the response carries both the structured rows and a rendered table, so it can't trip the global ~45 KB limit); `capped` flips true when more remain and a `note` appears when the page was byte-trimmed. Read-only; LastLoginDate is live-only state. Dormancy ONLY \u2014 for active users with login access but ZERO permission-set/PSG assignments (the perm-set-less variant of this sweep), use sfi.live_zombie_accounts.",
         inputSchema: LIVE_INACTIVE_USERS_INPUT_SCHEMA
       },
+      {
+        name: "sfi.live_permset_holders",
+        description: "Opt-in live org: WHO HOLDS a permission set, permission set group, or profile \u2014 the name-by-name assignment roster (PermissionSetAssignment / User rows are runtime state, never in the vault; vault sfi.effective_permissions describes what a grantor GRANTS, not who holds it). `kind` defaults to 'auto' (probes PermissionSet \u2192 PermissionSetGroup \u2192 Profile by exact name/label; ambiguity or no-match is an honest error, never a guess). For a permission set the default `includeViaGroups: true` ALSO counts users who receive it through a PermissionSetGroup containing it (querying PermissionSetGroupComponent), reported separately as `directHolders` / `viaGroupHolders` with a deduped `totalAssignees` \u2014 direct-only rosters silently miss via-group holders (the classic wrong answer). kind 'profile' returns the User roster for the profile. Expired assignments are excluded and disclosed (`expiredExcluded`); active assignees only by default. True count first; `limit` (default 100, cap 500) + ~36 KB byte budget page the detail; keyset paging via `afterId`/`nextAfterId`; `groupBy: 'profile'` (default) adds per-profile buckets. Reverse direction (what does USER X hold) = sfi.live_user_permsets. Read-only; point-in-time as of queriedAt \u2014 never cached beyond the live-session TTL; roster is CURRENT org state, unlike vault answers.",
+        inputSchema: LIVE_PERMSET_HOLDERS_INPUT_SCHEMA
+      },
+      {
+        name: "sfi.live_zombie_accounts",
+        description: 'Opt-in live org: ZOMBIE accounts \u2014 active users with login access but ZERO permission-set/PSG assignments, via a single SOQL anti-join (Id NOT IN PermissionSetAssignment WHERE PermissionSet.IsOwnedByProfile = false; the IsOwnedByProfile filter is load-bearing \u2014 every user carries a system PSA row for their profile-owned set). When the org rejects the anti-join it falls back to a DISCLOSED client-side diff of two bounded queries (`method: \'client-diff\'`, capped scans flagged as a lower bound). Optional `minDaysInactive` additionally requires dormancy; Standard (human) users by default. True count first (`totalZombies`); `limit` (default 100, cap 500) + ~36 KB byte budget page the detail. HONESTY: a "zombie" still holds every permission its PROFILE grants \u2014 this reports "no permission-set/PSG assignments", NOT "no access". This is the perm-set-less variant of sfi.live_inactive_users, which covers dormancy only (and for who DOES hold a set, use sfi.live_permset_holders). Read-only; point-in-time.',
+        inputSchema: LIVE_ZOMBIE_ACCOUNTS_INPUT_SCHEMA
+      },
+      {
+        name: "sfi.live_group_members",
+        description: "Opt-in live org: WHO IS IN a queue or public group \u2014 the runtime GroupMember roster (metadata XML only carries DECLARED members, so the vault's member counts routinely say 0 while Setup-managed membership is live-only; vault sfi.empty_queues_and_groups reads the declared counts). Resolves the Group by exact DeveloperName/Name (`groupType` defaults to 'auto'; ambiguity or no-match is an honest error, never a guess). GroupMember.UserOrGroupId is polymorphic: users (005) are resolved name-by-name, nested groups (00G) are LISTED but not expanded, and Role / RoleAndSubordinates entries are surfaced by UserRole name and NEVER expanded to users. `expandNested: true` expands exactly ONE level of nested public groups, stamped `expansion: 'partial-one-level'` \u2014 deeper nesting and role-hierarchy subordinates are not enumerated; never treat a partial expansion as the full effective membership. Queues also return `supportedObjects` (QueueSobject \u2014 which sObjects the queue can own). Output cross-checks the vault: `vaultDeclaredMemberCount` vs `liveDirectMemberCount` with a `drift` boolean. True count first (`totalDirectMembers`); `limit` (default 100, cap 500) + ~36 KB byte budget page the user rows. Read-only; point-in-time as of queriedAt.",
+        inputSchema: LIVE_GROUP_MEMBERS_INPUT_SCHEMA
+      },
+      {
+        name: "sfi.live_user_permsets",
+        description: "Opt-in live org: WHAT does USER X hold \u2014 the reverse of sfi.live_permset_holders (input = a user, output = the grantors they hold: profile + direct permission sets + permission set groups, with expirations). Resolves the user by exact Username (preferred \u2014 unique) then exact Name; an ambiguous name returns an honest candidate list, never a guess. PSA rows are split `directPermsets` vs `viaGroups` (grouped by PermissionSetGroup); the query pins PermissionSet.IsOwnedByProfile = false so the user's profile-owned system PSA row never masquerades as a direct assignment \u2014 the profile is reported as `user.profileName` instead. Expired assignments are excluded and disclosed (`expiredExcluded`). DUAL PROVENANCE: this answers WHICH grantors the user holds (live, point-in-time as of queriedAt); vault sfi.effective_permissions answers WHAT those grantors grant \u2014 pair them, each half stamped with its own provenance. True count first (`totalAssignments`); `limit` (default 200, cap 500) + ~36 KB byte budget page the detail. Read-only.",
+        inputSchema: LIVE_USER_PERMSETS_INPUT_SCHEMA
+      },
       {
         name: "sfi.live_license_usage",
         description: "Opt-in live org: license / cost optimization. Returns UserLicense and PermissionSetLicense utilization (total / used / available / utilizationPct; unlimited licenses surface total: -1 \u2192 available/pct null) plus `reclaimableSeats` \u2014 active Standard users dormant past `inactiveDays` (default 90), grouped by their user license, the paid-seats-nobody-uses question. Honesty axis (verbatim): reclaimable seats is a PROXY (inactivity, not actual feature usage; some dormant seats are held intentionally; per-feature-license usage is not covered). READ-ONLY: never deprovisions or reassigns a license \u2014 verify each seat before reclaiming. License counts and LastLoginDate are live-only state.",
@@ -69757,7 +71938,7 @@ var init_tools = __esm({
       },
       {
         name: "sfi.effective_permissions",
-        description: "Compute a user's EFFECTIVE access \u2014 the UNION of a profile + assigned permission sets, max-wins, with each permission attributed to the container(s) that grant it. `why_cant_user_see_record` evaluates a single record question against a bundle; nothing else rolls the containers up into one combined ability \u2014 this does. Input: `profileId` and/or `permissionSetIds[]` (at least one). A `PermissionSetGroup:` id may be passed in `permissionSetIds[]` \u2014 it is EXPANDED into its member permission sets (declared membership) and unioned in, so a PSG-assigned user gets a real answer (a permset reachable both directly and via a group is unioned once, not double-counted). It composes each container's outgoing `grantedBy` edges (object + field + apex), `properties.userPermissions` (system perms), and `properties.recordTypeVisibilities` (record-type visibility). `objectPermissions[]` carries the OR'd `allowCreate`/`allowRead`/`allowEdit`/`allowDelete`/`viewAllRecords`/`modifyAllRecords` per object plus `grantedBy` (the containers contributing a flag); `systemPermissions[]` lists each user-permission with its `grantedBy`; `customPermissions[]` (CR-CAP-10) lists each granted custom permission with its `grantedBy` + `targetMissing` (true when the granted name has no `CustomPermission` definition in the vault \u2014 managed-package / not-retrieved; declared but not resolvable, and NOT folded into systemPermissions); `recordTypeVisibilities[]` unions each container's declared record-type visibility (max-wins \u2014 visible=true wins; `<visible>` omitted in older metadata counts as visible, only an explicit false hides), each entry `{recordType, visible, grantedBy}` \u2014 record-type visibility is part of THIS union now, no longer only the separate `recordtype_availability` surface (that tool remains for the per-object grouped view); a container carrying no extracted `recordTypeVisibilities` property (a vault refreshed before record-type extraction) contributes nothing and is DISCLOSED (re-run /sfi-refresh), never fabricated as 'no record types'; `summary` reports objects / fieldsWithFls / apexClasses / systemPermissions / customPermissions / recordTypeVisibilities counts. The object list PAGES (`limit` default 100 / max 200, `offset`/`hasMore`/`truncated`). `declared` confidence. `disclosures` is explicit about the boundaries: permission-set GROUP membership IS expanded, but muting permission sets are DISCLOSED, not subtracted (effective access may be lower); app/tab visibility is a SEPARATE surface (now extracted \u2014 see `app_access` / `tab_availability`), not part of this union; field-level detail is summarised (use `field_access_audit`); object permission is NOT record access (record visibility needs OWD + sharing); custom permissions are declared grants, NOT system userPermissions, so they are never double-counted. Missing containers are ignored with a disclosure; if none exist \u2192 `component-not-found`.",
+        description: "Compute a user's EFFECTIVE access \u2014 the UNION of a profile + assigned permission sets, max-wins, with each permission attributed to the container(s) that grant it. `why_cant_user_see_record` evaluates a single record question against a bundle; nothing else rolls the containers up into one combined ability \u2014 this does. Input: `profileId` and/or `permissionSetIds[]` (at least one). A `PermissionSetGroup:` id may be passed in `permissionSetIds[]` \u2014 it is EXPANDED into its member permission sets (declared membership) and unioned in, so a PSG-assigned user gets a real answer (a permset reachable both directly and via a group is unioned once, not double-counted). It composes each container's outgoing `grantedBy` edges (object + field + apex), `properties.userPermissions` (system perms), and `properties.recordTypeVisibilities` (record-type visibility). `objectPermissions[]` carries the OR'd `allowCreate`/`allowRead`/`allowEdit`/`allowDelete`/`viewAllRecords`/`modifyAllRecords` per object plus `grantedBy` (the containers contributing a flag); `systemPermissions[]` lists each user-permission with its `grantedBy`; `customPermissions[]` (CR-CAP-10) lists each granted custom permission with its `grantedBy` + `targetMissing` (true when the granted name has no `CustomPermission` definition in the vault \u2014 managed-package / not-retrieved; declared but not resolvable, and NOT folded into systemPermissions); `recordTypeVisibilities[]` unions each container's declared record-type visibility (max-wins \u2014 visible=true wins; `<visible>` omitted in older metadata counts as visible, only an explicit false hides), each entry `{recordType, visible, grantedBy}` \u2014 record-type visibility is part of THIS union now, no longer only the separate `recordtype_availability` surface (that tool remains for the per-object grouped view); a container carrying no extracted `recordTypeVisibilities` property (a vault refreshed before record-type extraction) contributes nothing and is DISCLOSED (re-run /sfi-refresh), never fabricated as 'no record types'; `summary` reports objects / fieldsWithFls / apexClasses / systemPermissions / customPermissions / recordTypeVisibilities counts. The object list PAGES (`limit` default 100 / max 200, `offset`/`hasMore`/`truncated`). `declared` confidence. `disclosures` is explicit about the boundaries: permission-set GROUP membership IS expanded, but muting permission sets are DISCLOSED, not subtracted (effective access may be lower); app/tab visibility is a SEPARATE surface (now extracted \u2014 see `app_access` / `tab_availability`), not part of this union; field-level detail is summarised (use `field_access_audit`); object permission is NOT record access (record visibility needs OWD + sharing); custom permissions are declared grants, NOT system userPermissions, so they are never double-counted. Missing containers are ignored with a disclosure; if none exist \u2192 `component-not-found`. DIRECTION: this answers WHAT a given container bundle GRANTS (vault metadata); WHICH sets/PSGs a specific USER actually holds right now is runtime assignment state \u2014 use sfi.live_user_permsets (live, read-only) and feed its grantors back into this tool for a dual-provenance answer.",
         inputSchema: EFFECTIVE_PERMISSIONS_INPUT_SCHEMA
       },
       {
@@ -70017,12 +72198,12 @@ var init_tools = __esm({
       },
       {
         name: "sfi.unassigned_permission_sets",
-        description: "v2.4 hygiene tool: list PermissionSets unassigned to users. The tool ships TWO output paths: (1) when v1.7 R2 Tooling-API enrichment has run, reads `properties.assignedUserCount` as the authoritative answer (PermissionSets with count 0 surface in `unassigned[]`); (2) when enrichment has not run, falls back to a structural check \u2014 PermissionSets with no outgoing `grantedBy` edges surface as `orphanedFromComponents[]`. The `unassignedCount` field counts confirmed unassigned; `unknownAssignmentCount` separately tallies PermissionSets where assignment cannot be determined. `enrichmentStatus` reports which path the answer came from (`tooling-api-fresh` / `tooling-api-stale` / `structural-only` / `no-assignment-data`). Honesty axis (v2.4 constitutional): NEVER counts unknownAssignmentCount toward unassignedCount \u2014 separates 'no data' from 'no assignments'. Emits a `coverageCaveat` when the PermissionSet family was not retrieved (distinct from the unknownAssignmentCount enrichment axis); empty results under it are 'not retrieved'. When the vault holds a captured permission-holder aggregate (`refresh --with-data-shape`), the response embeds a `dataShape` holders block (`data_snapshot`, COUNTS ONLY \u2014 no identities): a container absent from the org-wide aggregate had FACTUALLY zero active assignments at the capture stamp, upgrading the metadata inference.",
+        description: "v2.4 hygiene tool: list PermissionSets unassigned to users. The tool ships TWO output paths: (1) when v1.7 R2 Tooling-API enrichment has run, reads `properties.assignedUserCount` as the authoritative answer (PermissionSets with count 0 surface in `unassigned[]`); (2) when enrichment has not run, falls back to a structural check \u2014 PermissionSets with no outgoing `grantedBy` edges surface as `orphanedFromComponents[]`. The `unassignedCount` field counts confirmed unassigned; `unknownAssignmentCount` separately tallies PermissionSets where assignment cannot be determined. `enrichmentStatus` reports which path the answer came from (`tooling-api-fresh` / `tooling-api-stale` / `structural-only` / `no-assignment-data`). Honesty axis (v2.4 constitutional): NEVER counts unknownAssignmentCount toward unassignedCount \u2014 separates 'no data' from 'no assignments'. Emits a `coverageCaveat` when the PermissionSet family was not retrieved (distinct from the unknownAssignmentCount enrichment axis); empty results under it are 'not retrieved'. When the vault holds a captured permission-holder aggregate (`refresh --with-data-shape`), the response embeds a `dataShape` holders block (`data_snapshot`, COUNTS ONLY \u2014 no identities): a container absent from the org-wide aggregate had FACTUALLY zero active assignments at the capture stamp, upgrading the metadata inference. For the current name-by-name holder list of one specific container, use sfi.live_permset_holders (opt-in, read-only).",
         inputSchema: UNASSIGNED_PERMISSION_SETS_INPUT_SCHEMA
       },
       {
         name: "sfi.empty_queues_and_groups",
-        description: "v2.4 hygiene tool: list Queue and Group nodes with zero members. Walks `properties.memberCount` (the v1.1+ extractor convention) and falls back to `properties.queueMembers` / `properties.groupMembers` array length. The 'routing trap' case \u2014 a Queue with zero members but multiple incoming AssignmentRule references \u2014 surfaces with `incomingAssignmentRuleCount > 0`; admins must reassign routing before deletion. The `isLikelyStale` flag combines zero members + incoming refs + `lastModifiedAt > 180 days`. Member resolution that cannot decide ('unknown') is counted in `unknownMemberCountQueues` / `unknownMemberCountGroups`, NEVER toward emptiness. Honesty axis (verbatim): runtime membership changes via the Setup UI since the last vault refresh are not reflected. Emits a `coverageCaveat` (scoped to the type filter) when Queue/Group was not retrieved; empty lists under it are 'not checked', not 'none'.",
+        description: "v2.4 hygiene tool: list Queue and Group nodes with zero members. Walks `properties.memberCount` (the v1.1+ extractor convention) and falls back to `properties.queueMembers` / `properties.groupMembers` array length. The 'routing trap' case \u2014 a Queue with zero members but multiple incoming AssignmentRule references \u2014 surfaces with `incomingAssignmentRuleCount > 0`; admins must reassign routing before deletion. The `isLikelyStale` flag combines zero members + incoming refs + `lastModifiedAt > 180 days`. Member resolution that cannot decide ('unknown') is counted in `unknownMemberCountQueues` / `unknownMemberCountGroups`, NEVER toward emptiness. Honesty axis (verbatim): runtime membership changes via the Setup UI since the last vault refresh are not reflected \u2014 for the CURRENT runtime roster (and a measured vault-vs-live drift check), use sfi.live_group_members (opt-in, read-only). Emits a `coverageCaveat` (scoped to the type filter) when Queue/Group was not retrieved; empty lists under it are 'not checked', not 'none'.",
         inputSchema: EMPTY_QUEUES_AND_GROUPS_INPUT_SCHEMA
       },
       {
@@ -70506,6 +72687,14 @@ var init_tools = __esm({
           return runTool(ctx, args, liveOrgLimitsInputSchema, liveOrgLimitsHandler);
         case "sfi.live_inactive_users":
           return runTool(ctx, args, liveInactiveUsersInputSchema, liveInactiveUsersHandler);
+        case "sfi.live_permset_holders":
+          return runTool(ctx, args, livePermsetHoldersInputSchema, livePermsetHoldersHandler);
+        case "sfi.live_zombie_accounts":
+          return runTool(ctx, args, liveZombieAccountsInputSchema, liveZombieAccountsHandler);
+        case "sfi.live_group_members":
+          return runTool(ctx, args, liveGroupMembersInputSchema, liveGroupMembersHandler);
+        case "sfi.live_user_permsets":
+          return runTool(ctx, args, liveUserPermsetsInputSchema, liveUserPermsetsHandler);
         case "sfi.live_license_usage":
           return runTool(ctx, args, liveLicenseUsageInputSchema, liveLicenseUsageHandler);
         case "sfi.live_consent":
@@ -72446,7 +74635,7 @@ var init_package_version = __esm({
     "use strict";
     readCliPackageVersion = () => {
       if (true)
-        return "0.1.22";
+        return "0.1.24";
       for (const rel of ["../package.json", "../../package.json"]) {
         try {
           const raw = readFileSync3(fileURLToPath(new URL(rel, import.meta.url)), "utf8");
@@ -142342,13 +144531,13 @@ var registerMcpCommand = (program) => {
     process.env["SFI_PLUGIN_VERSION"] = readCliPackageVersion();
     process.stderr.write(`sfi mcp: serving vault ${vaultRoot}${targetOrg !== null ? ` (org: ${targetOrg})` : " (no targetOrg in config)"}
 `);
-    try {
-      const notice = formatUpdateNotice(await checkForUpdate(readCliPackageVersion()));
+    void checkForUpdate(readCliPackageVersion()).then((result) => {
+      const notice = formatUpdateNotice(result);
       if (notice !== null)
         process.stderr.write(`sfi mcp: ${notice}
 `);
-    } catch {
-    }
+    }, () => {
+    });
     const shutdownOnce = makeShutdownOnce(ctx);
     for (const signal of SHUTDOWN_SIGNALS) {
       process.on(signal, () => {
@@ -142370,7 +144559,7 @@ var makeShutdownOnce = (ctx) => {
 
 // dist/src/commands/demo.js
 init_refresh();
-var buildVersion = () => true ? "0.1.22" : "dev";
+var buildVersion = () => true ? "0.1.24" : "dev";
 var SHUTDOWN_SIGNALS2 = ["SIGINT", "SIGTERM"];
 var resolveDemoSource = () => {
   let dir = dirname21(fileURLToPath2(import.meta.url));
@@ -143355,7 +145544,7 @@ init_vault_git();
 init_watch();
 var readVersion = () => {
   if (true)
-    return "0.1.22";
+    return "0.1.24";
   const pkgUrl = new URL("../../package.json", import.meta.url);
   const raw = readFileSync6(fileURLToPath3(pkgUrl), "utf8");
   const parsed = JSON.parse(raw);