@elliotsystems/eai 0.1.7 → 0.1.14

package/plugin/opencode-plugin/src/compaction.ts

@@ -0,0 +1,600 @@
+/**
+ * Fast Jev Compaction — the ALGORITHM only (spec: `specs/2026-10-29-fast-
+ * jev-compaction-pilot.md`, task T6). Ported from the public `fast-jev-
+ * compaction` project's README (score each tool call/result via a yes/no
+ * judge, drop or truncate the ones no longer needed, keep everything else
+ * verbatim — never summarize/rewrite text) onto EAI's own message shape.
+ *
+ * This module is deliberately TRANSPORT-AGNOSTIC: no HTTP, no fetch, no
+ * knowledge of OpenRouter/Jev/the T3 backend endpoint. The two yes/no
+ * questions the algorithm needs answered for each candidate tool call are
+ * asked through the injected `asker` function parameter — the caller (T7)
+ * supplies an adapter that POSTs to the team-scoped backend proxy. Keeping
+ * the network entirely outside this file is what makes it unit-testable
+ * (T8) without a network mock framework, and keeps this module reusable if
+ * the transport ever changes.
+ *
+ * ## Shape this operates on
+ *
+ * A simplified, content-block message shape (`CompactionMessage`/
+ * `ContentBlock`) rather than OpenCode's own `{ info, parts }` wire shape —
+ * T7's adapter is responsible for converting one into the other before and
+ * after calling `compactMessages`. `tool_use`/`tool_result` blocks are
+ * paired by id, matching how Claude-style content blocks represent a tool
+ * round trip (an assistant message's `tool_use` block, answered by a later
+ * message's `tool_result` block carrying the same id).
+ *
+ * `info` is carried through unchanged on each `CompactionMessage` so this
+ * module can reuse `isBlockedAssistantTurn` (see "Guardrail interplay"
+ * below) without needing to know anything else about OpenCode's message
+ * shape.
+ *
+ * ## Algorithm, in order
+ *
+ * 1. Pin message 0 ("the first message"), the first `user`-role message
+ *    (covers the case where index 0 is a separate system prompt), and the
+ *    newest `preserveRecentMessages` messages (default 6).
+ * 2. Pair every `tool_use` block with its `tool_result` block by id. A pair
+ *    is a CANDIDATE only when neither its call message nor its result
+ *    message is pinned, blocked (see below), or still missing a result.
+ * 3. Build `state`: a clone of the full message list where every candidate
+ *    pair's result content is replaced with a short `ok, N chars (omitted)`
+ *    note. This is the cheap representation fed to the judge, never what a
+ *    KEPT item ends up looking like in the final output.
+ * 4. Fit `state` under `maxStateTokens` via STAGED truncation, applied in
+ *    this exact order, stopping as soon as the ceiling is met:
+ *    a. candidate tool inputs truncated to 1000, then 200, then 60 chars;
+ *    b. old (non-pinned, non-blocked) text blocks abridged head+tail;
+ *    c. old messages collapsed to a single placeholder;
+ *    d. old tool calls reduced to one line.
+ * 5. For every candidate pair, call `asker` once with enough context
+ *    (drawn from the FITTED state, not the raw original) to get back
+ *    `keepCall`/`keepResult` — each a 0..1 "yes" strength, not necessarily
+ *    a strict boolean, so a threshold can be tuned without changing this
+ *    module.
+ * 6. Apply `keepThreshold` (default 0.5) to the ORIGINAL (verbatim)
+ *    messages, never the truncated `state`:
+ *    - `keepResult >= threshold` -> keep both verbatim;
+ *    - else `keepCall >= threshold` -> keep the call verbatim, replace the
+ *      result with the same short omitted note `state` used;
+ *    - else -> drop both blocks entirely.
+ * 7. Rebuild the message list: a message left with no content blocks is
+ *    removed outright; a `tool_result` whose `tool_use` was dropped is
+ *    removed too (never left orphaned), even though step 6 already drops
+ *    both halves of a pair together — this is a second, defensive pass.
+ *
+ * ## Token estimation
+ *
+ * A calibrated heuristic, not a real tokenizer (no new dependency): ~1
+ * token per 6 letters, 0.5 token per digit, ~1 token per other (non-
+ * whitespace) symbol. Good enough for a staged-truncation ceiling; never
+ * presented as an exact count.
+ *
+ * ## Guardrail interplay (explicit, not incidental)
+ *
+ * `isBlockedAssistantTurn` (reused verbatim from `./blocked-turns.js`, not
+ * reimplemented) flags a Jev-blocked assistant turn. Any message it flags
+ * is treated exactly like a pinned message here: never a compaction
+ * candidate, never truncated, never dropped. In the normal running system
+ * `stripBlockedTurns` already removes these turns upstream before this
+ * module ever sees them — this check exists so that if `stripBlockedTurns`
+ * is ever disabled or reordered independently, this module cannot
+ * re-introduce or corrupt a blocked turn by treating it as ordinary
+ * history to compact.
+ */
+import { isBlockedAssistantTurn } from "./blocked-turns.js"
+
+// ------------------------------------------------------------------ types --
+
+export type MessageRole = "system" | "user" | "assistant"
+
+export interface TextBlock {
+  readonly type: "text"
+  readonly text: string
+}
+
+export interface ToolUseBlock {
+  readonly type: "tool_use"
+  readonly id: string
+  readonly name: string
+  readonly input: unknown
+}
+
+export interface ToolResultBlock {
+  readonly type: "tool_result"
+  readonly tool_use_id: string
+  readonly content: string
+}
+
+export type ContentBlock = TextBlock | ToolUseBlock | ToolResultBlock
+
+/** The raw host `info` object a message carries, narrowed to exactly what
+ *  `isBlockedAssistantTurn` reads -- so this module stays usable with
+ *  OpenCode's real `{ info, parts }` shape without importing it. */
+export type CompactionMessageInfo = Parameters<typeof isBlockedAssistantTurn>[0]
+
+export interface CompactionMessage {
+  readonly role: MessageRole
+  readonly content: string | readonly ContentBlock[]
+  /** Passed through unchanged; only ever read by `isBlockedAssistantTurn`. */
+  readonly info?: CompactionMessageInfo
+}
+
+/** What the `asker` is given to answer `keepCall`/`keepResult` for one
+ *  candidate tool round trip. Drawn from the FITTED `state`, never the raw
+ *  original -- that is the entire point of fitting `state` under a ceiling
+ *  first. */
+export interface AskerContext {
+  readonly id: string
+  readonly toolName: string
+  readonly input: unknown
+  readonly resultSummary: string
+  /** The full fitted state, for a judge that wants broader context than
+   *  just this one call/result pair. */
+  readonly state: readonly CompactionMessage[]
+}
+
+export interface AskerAnswer {
+  /** 0..1 strength of "yes, keep the call around." */
+  readonly keepCall: number
+  /** 0..1 strength of "yes, keep the result around." */
+  readonly keepResult: number
+}
+
+/** Transport-agnostic by design -- the caller supplies this; this module
+ *  never makes a network call itself. */
+export type Asker = (context: AskerContext) => Promise<AskerAnswer>
+
+export interface CompactionOptions {
+  /** How many of the newest messages are always pinned, in addition to the
+   *  first message and the first user message. */
+  readonly preserveRecentMessages?: number
+  /** `keepResult`/`keepCall` threshold (0..1) applied to the asker's
+   *  answers. */
+  readonly keepThreshold?: number
+  /** Token-estimate ceiling `state` is fit under before any candidate is
+   *  asked about. */
+  readonly maxStateTokens?: number
+  readonly asker: Asker
+}
+
+export interface CompactionStats {
+  readonly originalTokens: number
+  /** Token estimate of the fitted `state` sent to the judge -- T9 surfaces
+   *  this directly in spend-log metadata. */
+  readonly stateTokens: number
+  readonly finalTokens: number
+  /** `1 - finalTokens / originalTokens`; `0` when there was nothing to
+   *  reduce or `originalTokens` was `0`. */
+  readonly reductionRatio: number
+  readonly candidateCount: number
+  readonly droppedCount: number
+  readonly truncatedCount: number
+  readonly keptCount: number
+}
+
+export interface CompactionResult {
+  readonly messages: readonly CompactionMessage[]
+  readonly stats: CompactionStats
+}
+
+export const DEFAULT_PRESERVE_RECENT_MESSAGES = 6
+export const DEFAULT_KEEP_THRESHOLD = 0.5
+/** No ceiling is specified by the ported algorithm's own README; this is a
+ *  conservative default a caller can override via `CompactionOptions.
+ *  maxStateTokens` once real pilot data suggests a better number. */
+export const DEFAULT_MAX_STATE_TOKENS = 12_000
+
+// ------------------------------------------------------------ tokenizing --
+
+/** Calibrated heuristic, not a real tokenizer: ~1 token per 6 letters, 0.5
+ *  per digit, ~1 per other non-whitespace symbol. See module docstring. */
+export function estimateTokens(text: string): number {
+  let tokens = 0
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i)
+    const isLetter = (code >= 65 && code <= 90) || (code >= 97 && code <= 122)
+    const isDigit = code >= 48 && code <= 57
+    const isWhitespace = code === 32 || code === 9 || code === 10 || code === 13
+    if (isLetter) tokens += 1 / 6
+    else if (isDigit) tokens += 0.5
+    else if (!isWhitespace) tokens += 1
+  }
+  return tokens
+}
+
+function blockText(block: ContentBlock): string {
+  if (block.type === "text") return block.text
+  if (block.type === "tool_use") return `${block.name} ${typeof block.input === "string" ? block.input : JSON.stringify(block.input)}`
+  return block.content
+}
+
+function messageText(message: CompactionMessage): string {
+  return typeof message.content === "string" ? message.content : message.content.map(blockText).join(" ")
+}
+
+export function estimateMessagesTokens(messages: readonly CompactionMessage[]): number {
+  let total = 0
+  for (const message of messages) total += estimateTokens(messageText(message))
+  return total
+}
+
+// --------------------------------------------------------------- pairing --
+
+interface ToolPair {
+  readonly id: string
+  readonly callMessageIndex: number
+  readonly callBlockIndex: number
+  readonly resultMessageIndex: number | null
+  readonly resultBlockIndex: number | null
+}
+
+function collectPairs(messages: readonly CompactionMessage[]): ToolPair[] {
+  const pairs = new Map<string, ToolPair>()
+
+  messages.forEach((message, messageIndex) => {
+    if (typeof message.content === "string") return
+    message.content.forEach((block, blockIndex) => {
+      if (block.type !== "tool_use") return
+      pairs.set(block.id, {
+        id: block.id,
+        callMessageIndex: messageIndex,
+        callBlockIndex: blockIndex,
+        resultMessageIndex: null,
+        resultBlockIndex: null,
+      })
+    })
+  })
+
+  messages.forEach((message, messageIndex) => {
+    if (typeof message.content === "string") return
+    message.content.forEach((block, blockIndex) => {
+      if (block.type !== "tool_result") return
+      const existing = pairs.get(block.tool_use_id)
+      if (!existing) return
+      pairs.set(block.tool_use_id, { ...existing, resultMessageIndex: messageIndex, resultBlockIndex: blockIndex })
+    })
+  })
+
+  return [...pairs.values()]
+}
+
+// ---------------------------------------------------------- pin/guardrail --
+
+function computePinnedIndices(messages: readonly CompactionMessage[], preserveRecentMessages: number): Set<number> {
+  const pinned = new Set<number>()
+  if (messages.length > 0) pinned.add(0)
+
+  const firstUserIndex = messages.findIndex((message) => message.role === "user")
+  if (firstUserIndex >= 0) pinned.add(firstUserIndex)
+
+  for (let i = Math.max(0, messages.length - preserveRecentMessages); i < messages.length; i++) pinned.add(i)
+  return pinned
+}
+
+/** Messages `isBlockedAssistantTurn` flags -- reused verbatim, never a
+ *  compaction candidate regardless of `preserveRecentMessages`. See module
+ *  docstring's "Guardrail interplay" section. */
+function computeBlockedIndices(messages: readonly CompactionMessage[]): Set<number> {
+  const blocked = new Set<number>()
+  messages.forEach((message, index) => {
+    if (message.role === "assistant" && isBlockedAssistantTurn(message.info)) blocked.add(index)
+  })
+  return blocked
+}
+
+// ---------------------------------------------------------------- clones --
+
+type MutableBlock = TextBlock | ToolUseBlock | ToolResultBlock
+interface MutableMessage {
+  role: MessageRole
+  info: CompactionMessageInfo
+  content: string | MutableBlock[]
+}
+
+function deepCloneValue<T>(value: T): T {
+  if (value === undefined) return value
+  return JSON.parse(JSON.stringify(value)) as T
+}
+
+function cloneBlock(block: ContentBlock): MutableBlock {
+  if (block.type === "tool_use") return { type: "tool_use", id: block.id, name: block.name, input: deepCloneValue(block.input) }
+  if (block.type === "tool_result") return { type: "tool_result", tool_use_id: block.tool_use_id, content: block.content }
+  return { type: "text", text: block.text }
+}
+
+function cloneMessages(messages: readonly CompactionMessage[]): MutableMessage[] {
+  return messages.map((message) => ({
+    role: message.role,
+    info: message.info,
+    content: typeof message.content === "string" ? message.content : message.content.map(cloneBlock),
+  }))
+}
+
+function omittedNote(length: number): string {
+  return `ok, ${length} chars (omitted)`
+}
+
+// ----------------------------------------------------- staged truncation --
+
+function truncateToolInputs(state: MutableMessage[], candidateCallIndices: ReadonlySet<number>, maxChars: number): void {
+  state.forEach((message, index) => {
+    if (!candidateCallIndices.has(index) || typeof message.content === "string") return
+    message.content = message.content.map((block) => {
+      if (block.type !== "tool_use") return block
+      const serialized = typeof block.input === "string" ? block.input : JSON.stringify(block.input)
+      if (serialized.length <= maxChars) return block
+      return { ...block, input: `${serialized.slice(0, maxChars)}... (truncated)` }
+    })
+  })
+}
+
+function abridgeText(text: string, headChars: number, tailChars: number): string {
+  if (text.length <= headChars + tailChars + 20) return text
+  const omitted = text.length - headChars - tailChars
+  return `${text.slice(0, headChars)}... [${omitted} chars omitted] ...${text.slice(text.length - tailChars)}`
+}
+
+function abridgeTexts(state: MutableMessage[], nonPinnedIndices: ReadonlySet<number>): void {
+  const headChars = 200
+  const tailChars = 200
+  state.forEach((message, index) => {
+    if (!nonPinnedIndices.has(index)) return
+    if (typeof message.content === "string") {
+      message.content = abridgeText(message.content, headChars, tailChars)
+      return
+    }
+    message.content = message.content.map((block) =>
+      block.type === "text" ? { ...block, text: abridgeText(block.text, headChars, tailChars) } : block,
+    )
+  })
+}
+
+function collapseMessages(state: MutableMessage[], nonPinnedIndices: ReadonlySet<number>): void {
+  state.forEach((message, index) => {
+    if (!nonPinnedIndices.has(index)) return
+    message.content = "[collapsed]"
+  })
+}
+
+function reduceToolCallsToOneLine(state: MutableMessage[], candidateCallIndices: ReadonlySet<number>): void {
+  state.forEach((message, index) => {
+    if (!candidateCallIndices.has(index) || typeof message.content === "string") return
+    message.content = message.content.map((block) =>
+      block.type === "tool_use" ? { ...block, input: "(call details omitted)" } : block,
+    )
+  })
+}
+
+function messagesTokensOf(state: readonly MutableMessage[]): number {
+  return estimateMessagesTokens(state as readonly CompactionMessage[])
+}
+
+/** Applies the four truncation stages, in the exact order the spec
+ *  requires, stopping the moment `state` fits under `maxStateTokens`. */
+function fitState(
+  state: MutableMessage[],
+  pinned: ReadonlySet<number>,
+  blocked: ReadonlySet<number>,
+  candidateCallIndices: ReadonlySet<number>,
+  maxStateTokens: number,
+): void {
+  if (messagesTokensOf(state) <= maxStateTokens) return
+
+  const nonPinned = new Set<number>()
+  state.forEach((_message, index) => {
+    if (!pinned.has(index) && !blocked.has(index)) nonPinned.add(index)
+  })
+
+  for (const maxChars of [1000, 200, 60]) {
+    truncateToolInputs(state, candidateCallIndices, maxChars)
+    if (messagesTokensOf(state) <= maxStateTokens) return
+  }
+
+  abridgeTexts(state, nonPinned)
+  if (messagesTokensOf(state) <= maxStateTokens) return
+
+  collapseMessages(state, nonPinned)
+  if (messagesTokensOf(state) <= maxStateTokens) return
+
+  reduceToolCallsToOneLine(state, candidateCallIndices)
+}
+
+// --------------------------------------------------------------- rebuild --
+
+function zeroStats(originalTokens: number): CompactionStats {
+  return {
+    originalTokens,
+    stateTokens: originalTokens,
+    finalTokens: originalTokens,
+    reductionRatio: 0,
+    candidateCount: 0,
+    droppedCount: 0,
+    truncatedCount: 0,
+    keptCount: 0,
+  }
+}
+
+function removeOrphanToolResults(messages: readonly CompactionMessage[]): CompactionMessage[] {
+  const callIds = new Set<string>()
+  for (const message of messages) {
+    if (typeof message.content === "string") continue
+    for (const block of message.content) if (block.type === "tool_use") callIds.add(block.id)
+  }
+
+  const cleaned: CompactionMessage[] = []
+  for (const message of messages) {
+    if (typeof message.content === "string") {
+      cleaned.push(message)
+      continue
+    }
+    const content = message.content.filter((block) => block.type !== "tool_result" || callIds.has(block.tool_use_id))
+    if (content.length === 0) continue
+    cleaned.push({ role: message.role, info: message.info, content })
+  }
+  return cleaned
+}
+
+function rebuildMessages(
+  messages: readonly CompactionMessage[],
+  dropIds: ReadonlySet<string>,
+  truncateResultIds: ReadonlySet<string>,
+  pairsById: ReadonlyMap<string, ToolPair>,
+): CompactionMessage[] {
+  const working: { role: MessageRole; info: CompactionMessageInfo; content: string | (ContentBlock | null)[] }[] =
+    messages.map((message) => ({
+      role: message.role,
+      info: message.info,
+      content: typeof message.content === "string" ? message.content : [...message.content],
+    }))
+
+  const setNull = (messageIndex: number, blockIndex: number): void => {
+    const content = working[messageIndex]?.content
+    if (!content || typeof content === "string") return
+    content[blockIndex] = null
+  }
+
+  for (const id of dropIds) {
+    const pair = pairsById.get(id)
+    if (!pair) continue
+    setNull(pair.callMessageIndex, pair.callBlockIndex)
+    if (pair.resultMessageIndex !== null && pair.resultBlockIndex !== null) {
+      setNull(pair.resultMessageIndex, pair.resultBlockIndex)
+    }
+  }
+
+  for (const id of truncateResultIds) {
+    const pair = pairsById.get(id)
+    if (!pair || pair.resultMessageIndex === null || pair.resultBlockIndex === null) continue
+    const content = working[pair.resultMessageIndex]?.content
+    if (!content || typeof content === "string") continue
+    const block = content[pair.resultBlockIndex]
+    if (block && block.type === "tool_result") {
+      content[pair.resultBlockIndex] = { type: "tool_result", tool_use_id: block.tool_use_id, content: omittedNote(block.content.length) }
+    }
+  }
+
+  const rebuilt: CompactionMessage[] = []
+  for (const message of working) {
+    const content = typeof message.content === "string" ? message.content : message.content.filter((b): b is ContentBlock => b !== null)
+    if (typeof content !== "string" && content.length === 0) continue
+    rebuilt.push({ role: message.role, info: message.info, content })
+  }
+
+  return removeOrphanToolResults(rebuilt)
+}
+
+function findBlock<T extends ContentBlock["type"]>(
+  state: readonly MutableMessage[],
+  messageIndex: number,
+  blockIndex: number,
+  type: T,
+): Extract<ContentBlock, { type: T }> | undefined {
+  const message = state[messageIndex]
+  if (!message || typeof message.content === "string") return undefined
+  const block = message.content[blockIndex]
+  if (!block || block.type !== type) return undefined
+  return block as Extract<ContentBlock, { type: T }>
+}
+
+// ------------------------------------------------------------------ main --
+
+/**
+ * Runs the Fast Jev Compaction algorithm over `messages`. See module
+ * docstring for the full step-by-step description. Never mutates the input
+ * array or its messages.
+ */
+export async function compactMessages(
+  messages: readonly CompactionMessage[],
+  options: CompactionOptions,
+): Promise<CompactionResult> {
+  const preserveRecentMessages = options.preserveRecentMessages ?? DEFAULT_PRESERVE_RECENT_MESSAGES
+  const keepThreshold = options.keepThreshold ?? DEFAULT_KEEP_THRESHOLD
+  const maxStateTokens = options.maxStateTokens ?? DEFAULT_MAX_STATE_TOKENS
+  const { asker } = options
+
+  const originalTokens = estimateMessagesTokens(messages)
+  if (messages.length === 0) {
+    return { messages: [], stats: zeroStats(originalTokens) }
+  }
+
+  const pinned = computePinnedIndices(messages, preserveRecentMessages)
+  const blocked = computeBlockedIndices(messages)
+  const allPairs = collectPairs(messages)
+
+  const candidates = allPairs.filter((pair) => {
+    if (pair.resultMessageIndex === null) return false
+    if (pinned.has(pair.callMessageIndex) || blocked.has(pair.callMessageIndex)) return false
+    if (pinned.has(pair.resultMessageIndex) || blocked.has(pair.resultMessageIndex)) return false
+    return true
+  })
+
+  if (candidates.length === 0) {
+    return { messages: [...messages], stats: zeroStats(originalTokens) }
+  }
+
+  const candidateCallIndices = new Set(candidates.map((pair) => pair.callMessageIndex))
+  const pairsById = new Map(candidates.map((pair) => [pair.id, pair] as const))
+
+  const state = cloneMessages(messages)
+  for (const pair of candidates) {
+    if (pair.resultMessageIndex === null || pair.resultBlockIndex === null) continue
+    const message = state[pair.resultMessageIndex]
+    if (!message || typeof message.content === "string") continue
+    const block = message.content[pair.resultBlockIndex]
+    if (!block || block.type !== "tool_result") continue
+    message.content[pair.resultBlockIndex] = { type: "tool_result", tool_use_id: block.tool_use_id, content: omittedNote(block.content.length) }
+  }
+
+  fitState(state, pinned, blocked, candidateCallIndices, maxStateTokens)
+  const stateTokens = messagesTokensOf(state)
+
+  let droppedCount = 0
+  let truncatedCount = 0
+  let keptCount = 0
+  const dropIds = new Set<string>()
+  const truncateResultIds = new Set<string>()
+
+  for (const pair of candidates) {
+    const callBlock = findBlock(state, pair.callMessageIndex, pair.callBlockIndex, "tool_use")
+    const resultBlock =
+      pair.resultMessageIndex !== null && pair.resultBlockIndex !== null
+        ? findBlock(state, pair.resultMessageIndex, pair.resultBlockIndex, "tool_result")
+        : undefined
+
+    const answer = await asker({
+      id: pair.id,
+      toolName: callBlock?.name ?? "unknown",
+      input: callBlock?.input,
+      resultSummary: resultBlock?.content ?? "",
+      state: state as readonly CompactionMessage[],
+    })
+
+    if (answer.keepResult >= keepThreshold) {
+      keptCount += 1
+    } else if (answer.keepCall >= keepThreshold) {
+      truncateResultIds.add(pair.id)
+      truncatedCount += 1
+    } else {
+      dropIds.add(pair.id)
+      droppedCount += 1
+    }
+  }
+
+  const finalMessages = rebuildMessages(messages, dropIds, truncateResultIds, pairsById)
+  const finalTokens = estimateMessagesTokens(finalMessages)
+
+  return {
+    messages: finalMessages,
+    stats: {
+      originalTokens,
+      stateTokens,
+      finalTokens,
+      reductionRatio: originalTokens > 0 ? 1 - finalTokens / originalTokens : 0,
+      candidateCount: candidates.length,
+      droppedCount,
+      truncatedCount,
+      keptCount,
+    },
+  }
+}

package/plugin/opencode-plugin/src/elliot-auth.ts

@@ -50,6 +50,16 @@ export interface ElliotConfig {
   backend_url?: string
   litellm_base_url?: string
   litellm_master_key?: string
+  /** The organization this config was written for — present since `eai
+   *  setup` has always spread the onboarding response (which always
+   *  includes it) into this file. Typed here (was previously only reachable
+   *  through the index signature) because guardrail-sync.ts needs it to
+   *  call `GET /teams/{team_id}` with the right tenant context. */
+  tenant_id?: string
+  /** The single team this config was scoped to at `eai setup` time — absent
+   *  for a tenant-wide (owner/admin) setup, which has no one team to check
+   *  a guardrail for. See guardrail-sync.ts. */
+  team_id?: string
   /**
    * Every credential this person can use, personal key first (Phase 4).
    * Absent on a config written by an older `eai setup` (or a backend that