@agent-native/core 0.98.6 → 0.98.7

package/corpus/core/src/integrations/adapters/slack.ts

@@ -56,6 +56,31 @@ const slackIdentityCache = new Map<
   { identity: SlackUserIdentity | null; expiresAt: number }
 >();
 
+// Deduped system notices send at most once per key per TTL so senders are
+// informed without being spammed per message. Callers pick the window: the
+// anonymous-tier heads-up uses the default day-long TTL; decline replies pass
+// a short TTL so a persistent condition still reminds the sender occasionally.
+const SLACK_SYSTEM_NOTICE_DEDUPE_TTL_MS = 24 * 60 * 60 * 1_000;
+const SLACK_SYSTEM_NOTICE_CACHE_MAX_ENTRIES = 1_000;
+const slackSystemNoticeCache = new Map<string, number>();
+
+/** Returns true when a deduped notice should send now, claiming the slot. */
+function claimSlackSystemNoticeSlot(
+  key: string,
+  ttlMs = SLACK_SYSTEM_NOTICE_DEDUPE_TTL_MS,
+): boolean {
+  const now = Date.now();
+  const expiresAt = slackSystemNoticeCache.get(key);
+  if (expiresAt && expiresAt > now) return false;
+  if (expiresAt) slackSystemNoticeCache.delete(key);
+  if (slackSystemNoticeCache.size >= SLACK_SYSTEM_NOTICE_CACHE_MAX_ENTRIES) {
+    const oldestKey = slackSystemNoticeCache.keys().next().value;
+    if (oldestKey) slackSystemNoticeCache.delete(oldestKey);
+  }
+  slackSystemNoticeCache.set(key, now + ttlMs);
+  return true;
+}
+
 export interface SlackAdapterOptions {
   /** Resolve the bot token for the exact Slack installation. */
   resolveBotToken?: (incoming: IncomingMessage) => Promise<string | undefined>;
@@ -264,7 +289,10 @@ export function slackAdapter(
           triggerKind: isDm ? "dm" : isMention ? "mention" : "thread_reply",
           conversationType: isDm ? "dm" : "unknown",
           tenantId: teamId,
-          actorTrust: { memberType: "unknown", verified: true },
+          // The signed Slack envelope authenticates the workspace, not the
+          // sender's membership tier. `users.info` hydration below is the
+          // authority that may promote this to a verified member.
+          actorTrust: { memberType: "unknown", verified: false },
           platformContext: {
             channelId: e.channel,
             channelType: e.channel_type,
@@ -493,6 +521,48 @@ export function slackAdapter(
       }
     },
 
+    async sendSystemNotice(
+      incoming: IncomingMessage,
+      text: string,
+      opts?: { dedupeKey?: string; dedupeTtlMs?: number },
+    ): Promise<void> {
+      if (!text.trim()) return;
+      const dedupeKey = opts?.dedupeKey;
+      if (
+        dedupeKey &&
+        !claimSlackSystemNoticeSlot(dedupeKey, opts?.dedupeTtlMs)
+      ) {
+        return;
+      }
+      try {
+        const token = await resolveBotToken(incoming);
+        if (!token) {
+          if (dedupeKey) slackSystemNoticeCache.delete(dedupeKey);
+          return;
+        }
+        const channelId = incoming.platformContext.channelId;
+        if (typeof channelId !== "string" || !channelId) {
+          if (dedupeKey) slackSystemNoticeCache.delete(dedupeKey);
+          return;
+        }
+        const threadTs =
+          typeof incoming.platformContext.threadTs === "string"
+            ? incoming.platformContext.threadTs
+            : undefined;
+        await postFresh(token, channelId, threadTs, {
+          text,
+          unfurl_links: false,
+          unfurl_media: false,
+          mrkdwn: true,
+        });
+      } catch (error) {
+        // A failed delivery did not inform the sender, so release the slot and
+        // allow the next message to retry instead of suppressing notices for a day.
+        if (dedupeKey) slackSystemNoticeCache.delete(dedupeKey);
+        throw error;
+      }
+    },
+
     async sendMessageToTarget(
       message: OutgoingMessage,
       target: OutboundTarget,
@@ -1137,15 +1207,18 @@ async function resolveSlackUserIdentity(
                 : typeof user.user.name === "string" && user.user.name.trim()
                   ? user.user.name.trim()
                   : null,
-        memberType: user.user.is_ultra_restricted
-          ? "external"
-          : user.user.is_restricted
-            ? "guest"
-            : user.user.is_owner
-              ? "owner"
-              : user.user.is_admin
-                ? "admin"
-                : "member",
+        // is_stranger marks Slack Connect DM participants from another
+        // workspace; they must map to "external", never "member".
+        memberType:
+          user.user.is_stranger || user.user.is_ultra_restricted
+            ? "external"
+            : user.user.is_restricted
+              ? "guest"
+              : user.user.is_owner
+                ? "owner"
+                : user.user.is_admin
+                  ? "admin"
+                  : "member",
       }
     : null;
   if (slackIdentityCache.size >= SLACK_IDENTITY_CACHE_MAX_ENTRIES) {
@@ -1168,7 +1241,13 @@ async function hydrateSlackIdentity(
   incoming: IncomingMessage,
 ): Promise<IncomingMessage> {
   const identity = await resolveSlackUserIdentity(token, incoming);
-  if (!identity) return incoming;
+  if (!identity) {
+    return {
+      ...incoming,
+      senderVerified: false,
+      actorTrust: { memberType: "unknown", verified: false },
+    };
+  }
   return {
     ...incoming,
     ...(identity.name ? { senderName: identity.name } : {}),
@@ -1299,8 +1378,6 @@ async function hydrateSlackContext(
     : [];
 
   const profile = identity;
-  const isGuest = identity?.memberType === "guest";
-  const isExternal = identity?.memberType === "external";
   const isPrivate = conversation?.channel?.is_private === true;
   const isExternalShared = conversation?.channel?.is_ext_shared === true;
   const isMpim = conversation?.channel?.is_mpim === true;
@@ -1348,12 +1425,15 @@ async function hydrateSlackContext(
       ? { senderEmail: profile.email, senderVerified: true }
       : { senderVerified: false }),
     conversationType,
-    actorTrust: {
-      memberType:
-        identity?.memberType ??
-        (isExternal ? "external" : isGuest ? "guest" : "member"),
-      verified: true,
-    },
+    // Conversation hydration must not promote a caller when users.info was
+    // unavailable. Preserve the result of the earlier identity-only hydration
+    // unless this request independently resolved the Slack user.
+    actorTrust: identity
+      ? { memberType: identity.memberType, verified: true }
+      : (incoming.actorTrust ?? {
+          memberType: "unknown",
+          verified: false,
+        }),
     contextMessages: hydratedMessages,
     ...(hydratedFiles.length ? { files: hydratedFiles.slice(0, 20) } : {}),
     platformContext: {

package/corpus/core/src/integrations/identity.ts

@@ -7,6 +7,34 @@ import {
 import { slackInstallationKey } from "./slack-oauth.js";
 import type { IncomingMessage, IntegrationExecutionContext } from "./types.js";
 
+export type IntegrationIdentityDeclineReason =
+  | "unverified"
+  | "guest"
+  | "unlinked-workspace"
+  | "membership-check-failed";
+
+/**
+ * Thrown when the default Slack DM identity ladder declines to run a message.
+ * `reason` is a stable machine-readable discriminator (used e.g. to dedupe
+ * decline replies); `userFacingMessage` is safe to send back to the sender as
+ * a polite reply; `message` stays log-only.
+ */
+export class IntegrationIdentityDeclinedError extends Error {
+  readonly reason: IntegrationIdentityDeclineReason;
+  readonly userFacingMessage: string;
+
+  constructor(
+    reason: IntegrationIdentityDeclineReason,
+    message: string,
+    userFacingMessage: string,
+  ) {
+    super(message);
+    this.name = "IntegrationIdentityDeclinedError";
+    this.reason = reason;
+    this.userFacingMessage = userFacingMessage;
+  }
+}
+
 function serviceOwner(platform: string): string {
   return `integration@${platform}`;
 }
@@ -47,17 +75,13 @@ async function resolveSlackInstallation(incoming: IncomingMessage) {
 }
 
 async function isMemberOfOrg(email: string, orgId: string): Promise<boolean> {
-  try {
-    const { rows } = await getDbExec().execute({
-      sql: `SELECT 1 FROM org_members
+  const { rows } = await getDbExec().execute({
+    sql: `SELECT 1 FROM org_members
         WHERE org_id = ? AND LOWER(email) = ?
         LIMIT 1`,
-      args: [orgId, email],
-    });
-    return rows.length > 0;
-  } catch {
-    return false;
-  }
+    args: [orgId, email],
+  });
+  return rows.length > 0;
 }
 
 /**
@@ -65,8 +89,13 @@ async function isMemberOfOrg(email: string, orgId: string): Promise<boolean> {
  *
  * Slack DMs become a user principal only after the adapter has verified the
  * sender email and the email is already a member of the managed installation's
- * Agent Native organization. Shared channels deliberately stay service-scoped
- * so a channel message cannot borrow one participant's private permissions.
+ * Agent Native organization. Hydrated full workspace members whose email is
+ * missing, unverified, or not an organization member run as an anonymous
+ * org-scoped service principal instead — the same visibility shared channels
+ * get. Hydration failures, guests/external members, and workspaces without a
+ * connected organization are declined with a user-facing message. Shared
+ * channels deliberately stay service-scoped so a channel message cannot borrow
+ * one participant's private permissions.
  */
 export async function resolveDefaultIntegrationExecutionContext(
   incoming: IncomingMessage,
@@ -85,48 +114,83 @@ export async function resolveDefaultIntegrationExecutionContext(
     };
   }
 
-  const email = normalizedEmail(incoming.senderEmail);
-  if (
-    !email ||
-    incoming.senderVerified !== true ||
-    !incoming.senderId ||
-    !incoming.tenantId
-  ) {
-    throw new Error(
-      "Slack DM sender identity could not be verified; refusing to run with a service principal.",
+  // Hydration check first: a transient users.info failure must land on the
+  // retry decline here, never on the anonymous org-scoped tier below.
+  if (incoming.actorTrust?.verified !== true) {
+    throw new IntegrationIdentityDeclinedError(
+      "unverified",
+      "Slack DM sender identity could not be hydrated; declining instead of guessing a principal.",
+      "I couldn't verify your Slack identity just now, so I can't run this request. Please try again in a moment.",
     );
   }
   if (
-    incoming.actorTrust?.memberType === "guest" ||
-    incoming.actorTrust?.memberType === "external"
+    incoming.actorTrust.memberType === "guest" ||
+    incoming.actorTrust.memberType === "external"
   ) {
-    throw new Error(
-      "External or guest Slack members cannot use personal Agent Native permissions.",
+    throw new IntegrationIdentityDeclinedError(
+      "guest",
+      "External or guest Slack members cannot use this integration.",
+      "This assistant is only available to members of this workspace's organization.",
     );
   }
   if (!installation?.orgId) {
-    throw new Error(
+    throw new IntegrationIdentityDeclinedError(
+      "unlinked-workspace",
       "Slack workspace is not connected to an Agent Native organization.",
+      "This Slack workspace isn't connected to an organization yet.",
     );
   }
 
-  if (!(await isMemberOfOrg(email, installation.orgId))) {
-    throw new Error(
-      "Slack DM sender is not a member of the connected Agent Native organization.",
-    );
+  const email = normalizedEmail(incoming.senderEmail);
+  let isOrgMember = false;
+  if (
+    email &&
+    incoming.senderVerified === true &&
+    incoming.senderId &&
+    incoming.tenantId
+  ) {
+    try {
+      isOrgMember = await isMemberOfOrg(email, installation.orgId);
+    } catch {
+      // A membership-store outage is not evidence that the sender is merely
+      // unlinked. Fail closed instead of widening them to org-wide access.
+      throw new IntegrationIdentityDeclinedError(
+        "membership-check-failed",
+        "Slack DM organization membership could not be verified.",
+        "I couldn't verify your organization membership just now, so I can't run this request. Please try again in a moment.",
+      );
+    }
+  }
+  if (isOrgMember && email && incoming.senderId && incoming.tenantId) {
+    const link = await upsertVerifiedIntegrationIdentity({
+      platform: incoming.platform,
+      tenantId: incoming.tenantId,
+      externalUserId: incoming.senderId,
+      userEmail: email,
+      orgId: installation.orgId,
+    });
+    return {
+      ownerEmail: link.userEmail,
+      orgId: link.orgId,
+      principalType: "user",
+      installationId: installation.id,
+    };
   }
 
-  const link = await upsertVerifiedIntegrationIdentity({
-    platform: incoming.platform,
-    tenantId: incoming.tenantId,
-    externalUserId: incoming.senderId,
-    userEmail: email,
-    orgId: installation.orgId,
-  });
+  // Hydrated full workspace member (member/admin/owner) whose email is
+  // unverified, missing (legacy install without users:read.email), or not an
+  // organization member: run with the anonymous org-scoped service principal —
+  // the same visibility shared channels get. Nothing user-private is
+  // accessible. One structured line keeps 100%-anonymous workspaces (legacy
+  // scope missing) visible in logs.
+  console.warn(
+    `[integrations] anonymous org-scoped principal used: platform=${incoming.platform} teamId=${incoming.tenantId ?? "unknown"} emailPresent=${Boolean(email)} memberType=${incoming.actorTrust.memberType}`,
+  );
   return {
-    ownerEmail: link.userEmail,
-    orgId: link.orgId,
-    principalType: "user",
+    ownerEmail: serviceOwner(incoming.platform),
+    orgId: installation.orgId,
+    principalType: "service",
     installationId: installation.id,
+    anonymousMember: true,
   };
 }

package/corpus/core/src/integrations/plugin.ts

@@ -53,7 +53,10 @@ import {
   startGoogleDocsPoller,
   handlePushNotification,
 } from "./google-docs-poller.js";
-import { resolveDefaultIntegrationExecutionContext } from "./identity.js";
+import {
+  IntegrationIdentityDeclinedError,
+  resolveDefaultIntegrationExecutionContext,
+} from "./identity.js";
 import {
   disconnectIntegrationInstallation,
   listIntegrationInstallations,
@@ -252,6 +255,11 @@ type IntegrationCredentialContext = {
 
 const REMOTE_DEVICE_ONLINE_MS = 90_000;
 
+// One decline reply per sender + decline reason per window: during a Slack
+// API outage every message would otherwise get another identical "try again"
+// reply. Short enough that a persistent condition still reminds the sender.
+const DECLINE_NOTICE_DEDUPE_TTL_MS = 5 * 60 * 1_000;
+
 export async function enqueueRemoteCommand(
   envelope: RemoteCodeCommandEnvelope,
 ): Promise<Record<string, unknown>> {
@@ -2378,14 +2386,48 @@ export function createIntegrationsPlugin(
                 () => resolveDefaultIntegrationExecutionContext(incoming!),
               );
             } catch (err) {
-              // An app-specific resolver may intentionally support a legacy
-              // Slack setup. When no override exists, the branch below fails
-              // closed instead of falling back to a service principal.
-              if (!options?.resolveExecutionContext && !options?.resolveOwner) {
-                console.error(
-                  `[integrations] default Slack DM identity denied message:`,
-                  err,
-                );
+              // Only an explicit execution-context resolver may override the
+              // default Slack identity ladder. The legacy owner-only resolver
+              // predates org-bound identities and must not turn a rejected DM
+              // into an authenticated owner run.
+              if (!options?.resolveExecutionContext) {
+                const declined =
+                  err instanceof IntegrationIdentityDeclinedError ? err : null;
+                if (declined) {
+                  console.warn(
+                    `[integrations] default Slack DM identity declined message:`,
+                    declined.message,
+                  );
+                  // Best-effort polite reply back to the DM, deduped per
+                  // sender + reason so an outage doesn't produce an identical
+                  // reply for every message. Do not await Slack's API: webhook
+                  // acknowledgement has a stricter deadline than notice
+                  // delivery and must not be delayed by a slow postMessage.
+                  void withCredentialContext(credentialContext, () =>
+                    adapter.sendSystemNotice
+                      ? adapter.sendSystemNotice(
+                          incoming!,
+                          declined.userFacingMessage,
+                          {
+                            dedupeKey: `decline:${incoming!.tenantId ?? "unknown"}:${incoming!.senderId ?? "unknown"}:${declined.reason}`,
+                            dedupeTtlMs: DECLINE_NOTICE_DEDUPE_TTL_MS,
+                          },
+                        )
+                      : Promise.resolve(),
+                  ).catch((noticeErr) => {
+                    console.warn(
+                      `[integrations] decline notice failed:`,
+                      noticeErr instanceof Error
+                        ? noticeErr.message
+                        : noticeErr,
+                    );
+                  });
+                } else {
+                  console.error(
+                    `[integrations] default Slack DM identity denied message:`,
+                    err,
+                  );
+                }
                 setResponseStatus(event, 200);
                 return "ok";
               }
@@ -2413,6 +2455,36 @@ export function createIntegrationsPlugin(
             }
           } else if (defaultExecutionContext) {
             executionContext = defaultExecutionContext;
+            if (defaultExecutionContext.anonymousMember) {
+              // The anonymous tier must never be silent. (1) The agent run
+              // can tell: the note rides the serialized `incoming` into the
+              // queued task and surfaces via <integration-context>.
+              incoming.identityNote =
+                "Caller is an unlinked Slack workspace member running with organization-wide visibility only; personal or privately-shared data is not accessible. They can get personal access by having an admin add their Slack email to the organization (or by reconnecting Slack with the users:read.email scope).";
+              // (2) The sender gets a one-time heads-up (adapter-throttled per
+              // sender). Fire-and-forget so it never delays or replaces the
+              // normal agent run.
+              if (adapter.sendSystemNotice) {
+                const senderEmail =
+                  typeof incoming.senderEmail === "string" &&
+                  incoming.senderEmail.trim()
+                    ? incoming.senderEmail.trim()
+                    : null;
+                const noticeText = senderEmail
+                  ? `Heads up: I couldn't match your Slack account to an organization member, so I can only use org-wide data. Ask an admin to add ${senderEmail} to the organization for personal access.`
+                  : "Heads up: I couldn't verify your Slack account's email, so I can only use org-wide data. Ask an admin to update the Slack connection with the users:read.email scope for personal access.";
+                void withCredentialContext(credentialContext, () =>
+                  adapter.sendSystemNotice!(incoming!, noticeText, {
+                    dedupeKey: `anonymous-tier:${incoming.tenantId ?? "unknown"}:${incoming.senderId ?? "unknown"}`,
+                  }),
+                ).catch((noticeErr) => {
+                  console.warn(
+                    `[integrations] anonymous-tier notice failed:`,
+                    noticeErr instanceof Error ? noticeErr.message : noticeErr,
+                  );
+                });
+              }
+            }
           } else if (options?.resolveOwner) {
             try {
               executionContext.ownerEmail = await withCredentialContext(

package/corpus/core/src/integrations/types.ts

@@ -104,6 +104,13 @@ export interface IncomingMessage {
     targetAgent?: string;
     instruction: string;
   };
+  /**
+   * Trusted app-side note about the caller's identity/visibility tier, set
+   * after execution-context resolution (e.g. an anonymous org-scoped Slack
+   * member). Surfaced to the agent as integration context. Adapters must not
+   * copy this from user-controlled webhook payload fields.
+   */
+  identityNote?: string;
   /** Provider-native message/activity reference for contextual replies. */
   replyRef?: string;
   /** Message timestamp (epoch ms) */
@@ -311,6 +318,23 @@ export interface PlatformAdapter {
     opts?: { placeholderRef?: string },
   ): Promise<void>;
 
+  /**
+   * Send a short best-effort system notice to the conversation the incoming
+   * message arrived on (polite identity declines, one-time access guidance).
+   * Bypasses agent formatting. When `dedupeKey` is provided, the adapter may
+   * drop the notice if the same key was sent recently. Callers must treat
+   * failures as non-fatal.
+   */
+  sendSystemNotice?(
+    incoming: IncomingMessage,
+    text: string,
+    opts?: {
+      dedupeKey?: string;
+      /** Dedupe window for `dedupeKey`. Adapters pick a default when omitted. */
+      dedupeTtlMs?: number;
+    },
+  ): Promise<void>;
+
   /**
    * Optionally post a "working on it…" placeholder message immediately when a
    * webhook arrives, before the agent loop runs. Adapters that support
@@ -436,4 +460,10 @@ export interface IntegrationExecutionContext {
   principalType: "user" | "service";
   installationId?: string;
   scopeId?: string;
+  /**
+   * True when a hydrated full workspace member could not be matched to an
+   * organization member and runs with the anonymous org-scoped service
+   * principal (org-wide visibility only, nothing user-private).
+   */
+  anonymousMember?: boolean;
 }

package/corpus/core/src/integrations/webhook-handler.ts

@@ -745,6 +745,7 @@ async function processIncomingMessage(
     incoming.senderName ? `Sender name: ${incoming.senderName}` : null,
     incoming.senderEmail ? `Sender email: ${incoming.senderEmail}` : null,
     incoming.senderId ? `Sender ID: ${incoming.senderId}` : null,
+    incoming.identityNote ? `Caller identity: ${incoming.identityNote}` : null,
     incoming.sourceUrl ? `Source thread: ${incoming.sourceUrl}` : null,
     incoming.routingHint?.targetAgent
       ? `Required target agent: ${incoming.routingHint.targetAgent}`

package/corpus/core/src/mcp/builtin-tools.ts

@@ -858,8 +858,11 @@ function askAppTool(
   return {
     tool: tool(
       "Send a natural-language message to an app's AI agent and get its " +
-        "response. Use for complex, multi-step tasks needing the agent's " +
-        "reasoning and full app context. In a single-app project the 'app' " +
+        "response. Use this first for natural-language investigation, " +
+        "diagnosis, multi-step work, and changes; it runs with the app's " +
+        "full skills, instructions, tools, and context. Use direct action " +
+        "tools only for a known, bounded read or simple UI handoff. In a " +
+        "single-app project the 'app' " +
         "param is optional (defaults to this app). When 'app' names a " +
         "different workspace app it is routed there over A2A; the result's " +
         "'routedVia' field reports whether it ran cross-app or locally. " +

package/corpus/templates/analytics/.agents/skills/session-replay/SKILL.md

@@ -164,7 +164,10 @@ agent answers about browser recordings in the Analytics template.
   reintroducing a clamp) — as regression guards against reintroducing any
   viewport "recovery" or pointer-projection heuristic. Do not change their
   expectations merely to bless a new sanitizer or clamp; validate the affected
-  replay in a browser first.
+  replay in a browser first. An interim clamp for the exact 3,189x885 pair was
+  also deleted once the view-time redaction root cause was proven; the earlier
+  3,000-3,999px band was rejected because it also catches real 3440px-wide
+  displays. Neither the exact exception nor the band belongs in the player.
 - The event timeline soft-highlights the active marker, auto-scrolls it into
   view (pausing briefly after manual scroll), and supports search. It appears
   beside the player from ~880px content width upward.

package/corpus/templates/analytics/AGENTS.md

@@ -124,15 +124,15 @@ details live in `.agents/skills/`.
   `userId`/email parameter (e.g. `userId: "user@example.com"`) or recording/
   issue id — never by matching emails read back from previously displayed
   output.
-- Analytics opts into the framework's authenticated-read connector policy, so
-  every Analytics action explicitly marked GET + read-only +
-  `publicAgent.requiresAuth` is directly callable by a signed-in external
-  agent. This includes the incident reads above plus safe dashboard/analysis
-  reads. Generic core `db-schema` / `db-query` remain in-app agent tools and
-  are not automatically exposed because broad SQL/schema access is too
-  powerful to infer from read-only metadata. Writes remain `ask_app`-only.
-  Use the explicit catalog and `denyActions` policy for any unusually
-  sensitive read instead of exposing an unannotated action.
+- Analytics keeps its direct MCP surface explicitly curated, so external
+  agents should use `ask_app` for multi-step investigation and changes. The
+  six incident reads above are bounded, user/org-scoped fallback tools for
+  callers that already know which lookup they need. Generic core
+  `db-schema` / `db-query` remain in-app agent tools and are not exposed
+  directly because broad SQL/schema access is too powerful to infer from
+  read-only metadata. Writes remain `ask_app`-only. Use the explicit catalog
+  and `denyActions` policy for any unusually sensitive read instead of
+  exposing an unannotated action.
 - `/agents` is the Analytics home for admin surfaces. The default Monitoring
   view embeds the shared observability dashboard for traces, conversations,
   evals, experiments, and feedback. `/agents?view=dashboards` shows the

package/corpus/templates/analytics/changelog/2026-07-12-analytics-uses-the-full-in-app-agent-for-multi-step-incident.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-12
+---
+
+Analytics uses the full in-app agent for multi-step incident investigations, with direct read tools available for focused lookups.