sf-intelligence 0.1.23 → 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)
+      });
+    };
   }
 });
 
@@ -25151,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/,
@@ -25393,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",
@@ -25412,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.
         ]
       },
       {
@@ -25892,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",
@@ -25905,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
@@ -26410,70 +27384,81 @@ 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 (PermissionSetAssignment) is not modeled \u2014 capability gap.",
-        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.'
-        },
+        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: [
-          /\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/
+          // "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/
         ]
       },
       {
-        // HONEST GAP (round-2, q1948/q1559): "which PSG grants the X custom
-        // permission / the Y role" is a PermissionSetGroup COMPOSITION lookup —
-        // PSG membership/composition is not modeled (same boundary as the two PSG
-        // gaps above), and roles are not granted by PSGs at all, so substituting
-        // object_access_audit / effective_permissions would be confidently wrong.
-        // Requires the GROUP noun: "which permission SETS grant edit on X" (no
-        // `group`) stays on the real field/effective-permissions routes.
+        // 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: "vault",
-        tools: [],
-        liveRequired: false,
+        plane: "live",
+        tools: ["sfi.live_permset_holders"],
+        liveRequired: true,
         needsResolve: false,
-        reason: "Which permission set group grants a permission (PermissionSetGroup composition) 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-group-grants",
-          note: 'PermissionSetGroup composition/membership modeling is not built yet, so "which PSG grants X" cannot be answered. Do not substitute effective_permissions or object_access_audit \u2014 they cover permission sets and profiles, not PSG composition. (If X is a custom permission, sfi.resolve + the permission-set reverse lookup covers PERMISSION SETS granting it.)'
+          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: [
           // Tempered verb→grants gap: "which permission set groups REFERENCE a
@@ -26488,11 +27473,16 @@ var init_intent_router = __esm({
       },
       {
         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/,
@@ -32205,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",
@@ -32305,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",
@@ -34344,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),
@@ -34370,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,
@@ -34378,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",
@@ -49364,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";
@@ -49372,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;
@@ -49523,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,
@@ -49530,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`."
@@ -52847,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;
@@ -55386,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, GAP_FOLLOW_UP_SHAPES, detectGapShapedFollowUp, 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";
@@ -55477,6 +56526,27 @@ 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
@@ -55490,13 +56560,29 @@ var init_context_resolution = __esm({
       [/\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"]
@@ -55506,6 +56592,10 @@ var init_context_resolution = __esm({
         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]+:.+$/;
@@ -55593,16 +56683,49 @@ 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, SIMULATION_TAIL, WRITE_SENTENCE_INITIAL, WRITE_LEAD_IN, WRITE_TRAILING_FRAME, WRITE_MAKE_SCHEMA, WRITE_GIVE_GRANT, WRITE_GIVE_INITIAL, 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, 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 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,
+      // 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
@@ -55617,17 +56740,27 @@ 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_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;
-    WRITE_SENTENCE_INITIAL = new RegExp(`(?:^|[.!?;]\\s+)(?:please\\s+|just\\s+)?${WRITE_VERB_FILLER}(${WRITE_VERB}\\b[^.?!;]{0,80})`, "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}?";
@@ -55685,6 +56818,16 @@ var init_refusal_gates = __esm({
     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,
@@ -55770,6 +56913,15 @@ var init_refusal_gates = __esm({
         /\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,
@@ -55834,8 +56986,9 @@ var init_refusal_gates = __esm({
         return { kind: "injection-exfiltration", disclosure: INJECTION_DISCLOSURE };
       }
       if (!WRITE_EXCLUDER.test(q2)) {
-        const simulationFrame = SIMULATION_TAIL.test(q2);
-        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))?.[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 {
@@ -55857,6 +57010,16 @@ var init_refusal_gates = __esm({
       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) };
@@ -55936,7 +57099,13 @@ var init_funnel_utterances = __esm({
         "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?"
+        "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?",
@@ -56036,7 +57205,19 @@ var init_funnel_utterances = __esm({
         "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"
+        "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",
@@ -56059,7 +57240,17 @@ var init_funnel_utterances = __esm({
         "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"
+        "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?",
@@ -56286,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",
@@ -56446,9 +57689,13 @@ var init_funnel_utterances = __esm({
         "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). The genuinely-unanswerable directions stay gapped:
-        // "which USERS are in the group" (permset-user-roster) and "which PSG
-        // grants X" (permset-group-grants) are capability-gap intents, untouched.
+        // 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>?",
@@ -57494,7 +58741,17 @@ var init_funnel_utterances = __esm({
         "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?"
+        "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?",
@@ -57543,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";
@@ -57652,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"],
@@ -57953,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(" ");
@@ -58133,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, isToolNameMention, extractEntityQuery, NAME_IGNORABLE_WORD, looksLikeComponentName, extractExistenceProbeToken, inferEntityTypes, normLiteral, refineEntityResolution, resolveParentQualifier, applyGlossaryAliases, questionAssertsNameMultiplicity, 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, 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 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";
@@ -58478,7 +59747,7 @@ var init_route_question = __esm({
       };
     };
     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) => {
+    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;
@@ -58503,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];
@@ -58512,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 = [];
@@ -58560,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"])],
@@ -58793,6 +60114,8 @@ var init_route_question = __esm({
       "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"
     };
@@ -58809,6 +60132,14 @@ var init_route_question = __esm({
         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"
@@ -59086,7 +60417,7 @@ ${renderContextApplied(contextApplied2)}`
       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);
+      route.intent !== "component-type" && entityAmbiguityRequiresClarification(entityQuery, refinedEntityResolution, input2.question, routeTargetsSingleComponent(route));
       let entityEvidence = refinedEntityResolution !== null && refinedEntityResolution.disposition !== "none" ? {
         query: entityQuery,
         typeHints: entityTypes,
@@ -59112,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) {
@@ -59333,7 +60665,8 @@ ${renderContextApplied(contextApplied2)}`
             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"
+            "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 = {
@@ -59368,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",
@@ -68118,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";
@@ -68657,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: {
@@ -70316,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
       },
       {
@@ -70326,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
       },
       {
@@ -70406,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.",
@@ -70501,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
       },
       {
@@ -70761,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
       },
       {
@@ -71250,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":
@@ -73190,7 +74635,7 @@ var init_package_version = __esm({
     "use strict";
     readCliPackageVersion = () => {
       if (true)
-        return "0.1.23";
+        return "0.1.24";
       for (const rel of ["../package.json", "../../package.json"]) {
         try {
           const raw = readFileSync3(fileURLToPath(new URL(rel, import.meta.url)), "utf8");
@@ -143086,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, () => {
@@ -143114,7 +144559,7 @@ var makeShutdownOnce = (ctx) => {
 
 // dist/src/commands/demo.js
 init_refresh();
-var buildVersion = () => true ? "0.1.23" : "dev";
+var buildVersion = () => true ? "0.1.24" : "dev";
 var SHUTDOWN_SIGNALS2 = ["SIGINT", "SIGTERM"];
 var resolveDemoSource = () => {
   let dir = dirname21(fileURLToPath2(import.meta.url));
@@ -144099,7 +145544,7 @@ init_vault_git();
 init_watch();
 var readVersion = () => {
   if (true)
-    return "0.1.23";
+    return "0.1.24";
   const pkgUrl = new URL("../../package.json", import.meta.url);
   const raw = readFileSync6(fileURLToPath3(pkgUrl), "utf8");
   const parsed = JSON.parse(raw);