@elliotsystems/eai 0.1.7 → 0.1.14

package/lib/setup.js

@@ -36,6 +36,14 @@ const path = require("path")
 const PROVIDER_ID = "elliot"
 const GENERAL_MODEL_ID = "elliot-general"
 const CODER_MODEL_ID = "elliot-coder"
+// The guardrail name a team's own request-level `metadata.guardrails`
+// override names — must match the real `guardrail_name` LiteLLM's
+// `deploy/litellm/config.yaml` configures (`jev-policy`), and the exact
+// value `ProviderManager._guardrail_names_for_team` already injects for Web
+// Chat's own RAG/orchestration path. Restated here (mirrors `teamconfig.py`'s
+// own `JEV_GUARDRAIL_NAME`) rather than imported, since this file has no
+// dependency on that Python module — a test pins both equal.
+const JEV_GUARDRAIL_NAME = "jev-policy"
 
 /** Matches OpenCode's own resolution (xdg-basedir, whose fallback is ~/.config everywhere). */
 function opencodeConfigDir(env = process.env) {
@@ -107,8 +115,22 @@ function decodeJwtPayload(token) {
  * from OFFERING a model that will be rejected. Falsy (undefined/null/[]) —
  * every team until an admin restricts it — offers both, unchanged from
  * before this parameter existed.
+ *
+ * `jevPolicyEnabled` closes the cross-client enforcement gap the staging
+ * integration audit found: the backend's `ProviderManager.
+ * _guardrail_names_for_team` already injects the request-level `metadata.
+ * guardrails` override for Web Chat's own native RAG/orchestration
+ * completions when a team's `jev_policy_enabled` is set, but this CLI (like
+ * OpenCode) calls LiteLLM directly via `@ai-sdk/openai-compatible`, outside
+ * that Python code path — so the override never reached it. Straight from
+ * the same onboarding response's `jev_policy_enabled` field
+ * (`app/routers/onboarding.py`). `false`/undefined (every team until
+ * explicitly opted in) produces a config identical to one built before this
+ * parameter existed. Mirrors the identical fix in `app/services/opencode/
+ * teamconfig.py::build_opencode_config` for OpenCode's own web runtimes —
+ * same flag, same mechanism, second client.
  */
-function elliotProvider(litellmBaseUrl, identity = undefined, allowedModels = undefined) {
+function elliotProvider(litellmBaseUrl, identity = undefined, allowedModels = undefined, jevPolicyEnabled = false) {
   const base = String(litellmBaseUrl).replace(/\/+$/, "")
   const options = { baseURL: `${base}/v1`, apiKey: "{env:ELLIOT_TOKEN}" }
   const headers = litellmIdentityHeaders(identity)
@@ -119,7 +141,7 @@ function elliotProvider(litellmBaseUrl, identity = undefined, allowedModels = un
     // — EAI branding only, never the gateway's own vendor name.
     name: "EAI Gateway",
     options,
-    models: offeredModels(allowedModels),
+    models: offeredModels(allowedModels, jevPolicyEnabled),
   }
 }
 
@@ -131,18 +153,33 @@ function elliotProvider(litellmBaseUrl, identity = undefined, allowedModels = un
  * degrades to offering both for that listing only, exactly like the
  * backend's own fallback — LiteLLM still rejects any actual request the
  * team isn't allowed to make either way.
+ *
+ * `jevPolicyEnabled` adds `options.metadata.guardrails` to EACH offered
+ * model — see `elliotProvider`'s own docstring for why. A model-level
+ * `options` object is the one static, declarative opencode.json field
+ * confirmed (offline, against the real `@ai-sdk/openai-compatible`
+ * package) to reach the request body this CLI's runtime actually sends.
  */
-function offeredModels(allowedModels) {
+function offeredModels(allowedModels, jevPolicyEnabled = false) {
   const all = { [GENERAL_MODEL_ID]: { name: "EAI General" }, [CODER_MODEL_ID]: { name: "EAI Coder" } }
-  if (!allowedModels || allowedModels.length === 0) return all
-
-  const allowed = new Set(allowedModels)
-  const offered = Object.keys(all).filter((id) => allowed.has(id))
-  if (offered.length === 0) return all
-
-  const filtered = {}
-  for (const id of offered) filtered[id] = all[id]
-  return filtered
+  let result = all
+  if (allowedModels && allowedModels.length > 0) {
+    const allowed = new Set(allowedModels)
+    const offered = Object.keys(all).filter((id) => allowed.has(id))
+    if (offered.length > 0) {
+      const filtered = {}
+      for (const id of offered) filtered[id] = all[id]
+      result = filtered
+    }
+  }
+  if (jevPolicyEnabled) {
+    const withGuardrails = {}
+    for (const [id, entry] of Object.entries(result)) {
+      withGuardrails[id] = { ...entry, options: { metadata: { guardrails: [JEV_GUARDRAIL_NAME] } } }
+    }
+    result = withGuardrails
+  }
+  return result
 }
 
 /** The default `model` field, given whatever `models` ended up offered —
@@ -298,6 +335,15 @@ function elliotCommands() {
         "intentionally omitted\".\n\n" +
         "Do not list individual skills here; SKILLS.md is the skill index and " +
         "`/eai-skills` generates it.\n\n" +
+        "Append the standard operating guidance: call the " +
+        "`elliot_eai_agents_standard` tool (the `elliot` MCP server exposes it), " +
+        "and append its `markdown` value verbatim to the END of AGENTS.md under " +
+        "a `## Standard guidance` heading. That tool returns the same canonical " +
+        "sections every runtime-generated AGENTS.md carries, from the backend's " +
+        "single source of truth — do not paraphrase or rewrite them. If the tool " +
+        "is not available yet, try once more after `sleep 3` before skipping; a " +
+        "project initialised here should carry the same standard sections a " +
+        "team's runtime does.\n\n" +
         "When done, report the file written and the key facts you detected.",
     },
     "eai-skills": {
@@ -339,6 +385,7 @@ function writeOpencodeConfig(
   servers = undefined,
   identity = undefined,
   allowedModels = undefined,
+  jevPolicyEnabled = false,
 ) {
   const dir = opencodeConfigDir(env)
   const file = path.join(dir, "opencode.json")
@@ -362,7 +409,7 @@ function writeOpencodeConfig(
   // replacement. Every other key is the user's own and survives untouched.
   const { [PROVIDER_ID]: _ours, ...theirs } = existing.mcp || {}
   const mcp = { ...theirs, ...(servers || elliotMcpServers()) }
-  const provider = elliotProvider(litellmBaseUrl, identity, allowedModels)
+  const provider = elliotProvider(litellmBaseUrl, identity, allowedModels, jevPolicyEnabled)
   // Org commands are spread LAST, same rule as `mcp` above: this repairs a
   // stale `/usage` from an older package rather than leaving it, while a
   // user's own unrelated custom commands are untouched.
@@ -390,6 +437,16 @@ function writeOpencodeConfig(
     // Follows the restriction, not always General — a team restricted to
     // Coder-only must not default to a model its own menu just excluded.
     model: existing.model || `${PROVIDER_ID}/${defaultModelId(provider.models)}`,
+    // OpenCode's own self-updater can never succeed here: it detects its
+    // install method by grepping `npm list -g --depth=0` for `opencode-ai`,
+    // but opencode-ai is a pinned dependency of this package, not its own
+    // top-level global install, so that check never matches and `/update`
+    // (and the unprompted "Update available" notice) always dead-ends on
+    // "Installation method not found". `eai update` is the one supported
+    // update path (see lib/update.js) and is unaffected by this setting.
+    // Only defaulted, same as `model` above, so a user who already set their
+    // own `autoupdate` keeps it.
+    autoupdate: existing.autoupdate ?? false,
     mcp,
     command,
   }
@@ -539,23 +596,80 @@ function writeAgentFile(agent, env = process.env) {
 }
 
 /**
- * Every agent the backend's `eai_agents` response named, in one pass.
+ * Path to the manifest recording which files in the agents directory THIS
+ * launcher itself wrote on its last run.
+ *
+ * It is the one safe way to tell "ours, now stale" apart from "a user's own
+ * file that happens to live here" without guessing from the filename -- which
+ * is exactly the guess `elliotCommands()`'s "OURS TO REPLACE, THEIRS TO KEEP"
+ * rule exists to avoid making. A file never named in any manifest this
+ * launcher wrote is never touched, no matter what it's called.
+ */
+function agentManifestPath(dir) {
+  return path.join(dir, ".eai-manifest.json")
+}
+
+/** The manifest's own filenames, or `[]` for "none yet" -- missing, corrupt,
+ *  or never written are the same case: nothing to clean up against. */
+function readAgentManifest(manifestFile) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(manifestFile, "utf-8"))
+    return Array.isArray(parsed) ? parsed : []
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Every agent the backend's `eai_agents` response named, in one pass --
+ * and, via the manifest above, nothing it no longer names.
  *
  * `agents` is exactly the `eai_agents` array `fetchOnboardingConfig`'s
  * response carries (or `[]`/undefined for a backend that predates it, which
  * this treats as "nothing to write" rather than an error -- a CLI update
  * must not need a backend update released in lockstep, the same tolerance
  * `writeOpencodeConfig`'s own `servers` fallback already extends to
- * `mcp_servers`).
- *
- * Stale-file cleanup is deliberately NOT done here: deleting a file this
- * launcher did not just enumerate would mean trusting a naming convention to
- * tell an EAI-generated agent apart from one the user wrote themselves under
- * the same directory, which is exactly the kind of guess `elliotCommands()`'s
- * "OURS TO REPLACE, THEIRS TO KEEP" rule exists to avoid making.
+ * `mcp_servers`). `undefined` specifically (backend doesn't send the field at
+ * all) skips the manifest reconcile too -- it carries no information about
+ * what the agent set NOW is, so nothing is safe to remove.
+ *
+ * A RENAME is a REMOVAL from this function's point of view: migration 090
+ * is exactly this -- `dev` became `eai-dev` as the SAME backend row, but
+ * `writeAgentFile` only ever knows the key it's given today, so the file
+ * named after the OLD key is, from here, indistinguishable from an agent
+ * that was deleted outright. Either way, this launcher wrote it and it is
+ * no longer in the current set, which is the one condition that makes
+ * deleting it safe.
  */
 function writeAllAgentFiles(agents, env = process.env) {
-  return (agents || []).map((agent) => writeAgentFile(agent, env))
+  if (!Array.isArray(agents)) return []
+
+  const dir = path.join(opencodeConfigDir(env), "agents")
+  const manifestFile = agentManifestPath(dir)
+  const previousFiles = readAgentManifest(manifestFile)
+
+  const written = agents.map((agent) => writeAgentFile(agent, env))
+  const writtenNames = new Set(written.map((f) => path.basename(f)))
+
+  for (const name of previousFiles) {
+    if (writtenNames.has(name)) continue
+    try {
+      fs.unlinkSync(path.join(dir, name))
+    } catch {
+      // Already gone (hand-deleted, or a second setup run) -- not an error.
+    }
+  }
+
+  // Only touch the manifest -- and so only ever create the directory -- when
+  // there is something to record or clean up. An empty/undefined response
+  // with no prior manifest must leave the directory exactly as this function
+  // always has: never created at all.
+  if (written.length > 0 || previousFiles.length > 0) {
+    fs.mkdirSync(dir, { recursive: true })
+    fs.writeFileSync(manifestFile, JSON.stringify([...writtenNames].sort(), null, 2))
+  }
+
+  return written
 }
 
 /** Owner-only: this file holds a bearer token and a refresh token. */
@@ -611,7 +725,20 @@ async function fetchOnboardingConfig(backendUrl, tenantId, token, teamId) {
     headers: { Authorization: `Bearer ${token}` },
   })
   if (!res.ok) {
-    throw new Error(`backend returned ${res.status} fetching the organisation config`)
+    // Surface the backend's own detail when it sent one (e.g. the fail-closed
+    // "no budgeted credential" 503 — EAI_ONBOARDING_BILLING_AUDIT.md §7), so
+    // `eai login`/`eai setup`/`eai teams use` show an actionable message
+    // rather than a bare status code.
+    let detail = ""
+    try {
+      const body = await res.json()
+      if (body && typeof body.detail === "string") detail = body.detail
+    } catch {
+      // Non-JSON error body; fall back to the status below.
+    }
+    throw new Error(
+      detail || `backend returned ${res.status} fetching the organisation config`,
+    )
   }
   return (await res.json()) || {}
 }
@@ -694,6 +821,7 @@ async function runSetup(opts) {
     servers,
     identity,
     orgConfig.allowed_models,
+    orgConfig.jev_policy_enabled,
   )
 
   const agentFiles = writeAllAgentFiles(orgConfig.eai_agents, process.env)
@@ -738,4 +866,5 @@ module.exports = {
   PROVIDER_ID,
   GENERAL_MODEL_ID,
   CODER_MODEL_ID,
+  JEV_GUARDRAIL_NAME,
 }

package/lib/stage.js

@@ -29,6 +29,62 @@ const fs = require("fs")
 const os = require("os")
 const path = require("path")
 
+/**
+ * The JEV (fast-jev-compaction-opencode) plugin spec. NOT staged by default:
+ * pass it as `jevPlugin` to stage it alongside Elliot's own branding plugin.
+ * It is off because the plugin writes its own log lines onto the TUI (and its
+ * `github:` spec also triggers a Node `url.parse()` deprecation warning at
+ * load), with no option to silence either. Turn it on again once it can log to
+ * a file only.
+ *
+ * Registering it here does NOT mean compaction works: as of this writing its
+ * default backend ("typesafe") has no configured credential on a stock
+ * install, so its own compaction hook fails closed and OpenCode's native
+ * compaction runs instead -- confirmed by reading its own log output, not
+ * claimed from its source alone. A plugin that fails to load or fails inside
+ * its own hook does not block startup or touch Elliot's own plugin entry;
+ * OpenCode loads each plugin independently and logs a per-plugin failure
+ * rather than refusing to start (see opencode.log's own "failed to load
+ * plugin" entries for Elliot's branding plugin on a missing gatewayAlias,
+ * which never affected the rest of the session).
+ *
+ * A bare string, not a [spec, options] tuple: unlike Elliot's own plugin, it
+ * takes no required option here, so there is nothing to pass.
+ */
+const DEFAULT_JEV_PLUGIN_SPEC = "github:overbit/fast-jev-compaction-opencode"
+
+/**
+ * Credential-shaped keys this function refuses to ever write into a staged
+ * config file. Checked by NAME, not by guessing at a value's shape -- a
+ * deliberately conservative denylist, since the cost of missing a future
+ * secret-shaped option name is much higher than the cost of a false
+ * positive dropping a harmless key that happened to share a name.
+ */
+const JEV_PLUGIN_SECRET_OPTION_KEYS = new Set(["apiKey", "localApiKey"])
+
+/**
+ * `opts.jevPluginOptions`, minus any credential-shaped key -- see
+ * DEFAULT_JEV_PLUGIN_SPEC's own docstring above for why a secret should
+ * never reach here in the first place. `undefined`/non-object input
+ * returns `undefined` (no options tuple at all, same as omitting the
+ * field), never throws -- this must never be the reason staging fails.
+ */
+function jevPluginOptionsExcludingSecrets(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return undefined
+  const clean = {}
+  for (const [key, value] of Object.entries(raw)) {
+    if (JEV_PLUGIN_SECRET_OPTION_KEYS.has(key)) {
+      process.stderr.write(
+        `eai: refusing to write "${key}" into the staged JEV plugin config -- ` +
+          `credentials must be set as an environment variable (e.g. TYPESAFE_API_KEY), never in a config file.\n`,
+      )
+      continue
+    }
+    clean[key] = value
+  }
+  return Object.keys(clean).length > 0 ? clean : undefined
+}
+
 /**
  * The LiteLLM MCP gateway's alias, from `~/.elliot/config.json`'s
  * `gateway_alias` field -- `eai setup` writes it there straight out of
@@ -139,6 +195,27 @@ function stageOverlay(opts) {
   // from. See readGatewayAlias's own docstring for why `undefined` must not
   // become a guessed `"elliot"`.
   const gatewayAlias = opts.gatewayAlias
+  // OFF unless a caller passes a spec (the tests do; pass DEFAULT_JEV_PLUGIN_SPEC
+  // to turn it on). It was staged for every install, but the plugin copies each
+  // of its log lines to the console and has no option to stop it, so on every
+  // launch `[fast-jev-compaction-opencode] initialized {...}` was drawn into the
+  // TUI prompt box -- for a compaction hook that fails closed on a stock install
+  // anyway. See DEFAULT_JEV_PLUGIN_SPEC's docstring.
+  const jevPlugin = opts.jevPlugin || null
+  // Non-secret backend selection ONLY -- e.g. { backend: "systemone",
+  // localBaseUrl: "...", localModel: "..." } to point the plugin at a local
+  // decision model instead of its own TypeSafe-hosted default. NEVER a
+  // credential: the plugin already reads TYPESAFE_API_KEY straight from
+  // process.env on every call (jev-compaction-opencode's own client.ts),
+  // and the OpenCode child process already inherits this launcher's full
+  // environment (bin/eai's `childProcess.spawn(..., { env })`) -- there is
+  // no path by which a secret needs to pass through this function, through
+  // a JSON file this function writes, or through anything this launcher
+  // logs. `jevPluginOptionsExcludingSecrets` enforces that as a real
+  // invariant, not just an absence of code: an `apiKey`/`localApiKey` key
+  // here is dropped and a warning is written to stderr rather than ever
+  // reaching a file on disk.
+  const jevPluginOptions = jevPluginOptionsExcludingSecrets(opts.jevPluginOptions)
 
   const pluginSource = path.join(packageRoot, "plugin", "opencode-plugin")
   const themeSource = path.join(packageRoot, "config", "themes")
@@ -150,13 +227,13 @@ function stageOverlay(opts) {
 
   try {
     // `.staged` records the version, a content fingerprint of the source this
-    // tree was built from, AND the gateway alias baked into the written
-    // config -- re-staging on every launch would add hundreds of file copies
-    // to startup, but skipping it on an alias change would leave a machine
-    // running `eai setup` against a renamed gateway alias (or configuring it
-    // for the first time) stuck on the stale tui.json/opencode.json until
-    // something else invalidated the stamp.
-    const stamp = `${version} ${fingerprint(pluginSource)} ${gatewayAlias || ""}`.trim()
+    // tree was built from, the gateway alias baked into the written config,
+    // AND the JEV plugin spec -- re-staging on every launch would add
+    // hundreds of file copies to startup, but skipping it on any of these
+    // changing would leave a machine stuck on a stale tui.json/opencode.json
+    // (the alias case is the incident this already protects against; the JEV
+    // spec is the same risk the moment that spec is ever overridden).
+    const stamp = `${version} ${fingerprint(pluginSource)} ${gatewayAlias || ""} ${jevPlugin || ""} ${JSON.stringify(jevPluginOptions || {})}`.trim()
     const done = fs.existsSync(marker) && fs.readFileSync(marker, "utf8").trim() === stamp
     if (!done) {
       fs.rmSync(root, { recursive: true, force: true })
@@ -176,9 +253,13 @@ function stageOverlay(opts) {
       // OUT of the array entirely rather than included in a form guaranteed
       // to fail — "plain OpenCode chrome" is the same visible outcome either
       // way, but without logging a load error on every single launch.
-      const plugin = gatewayAlias
-        ? [[pluginDir, { serverNames: ["elliot"], gatewayAlias }]]
-        : []
+      // JEV is appended independently of gatewayAlias: it has no such
+      // required option (see DEFAULT_JEV_PLUGIN_SPEC), so there is nothing
+      // here that can fail validation the way a bare Elliot plugin path did.
+      const plugin = [
+        ...(gatewayAlias ? [[pluginDir, { serverNames: ["elliot"], gatewayAlias }]] : []),
+        ...(jevPlugin ? [jevPluginOptions ? [jevPlugin, jevPluginOptions] : jevPlugin] : []),
+      ]
       fs.writeFileSync(
         path.join(root, "tui.json"),
         JSON.stringify(
@@ -207,4 +288,4 @@ function stageOverlay(opts) {
   }
 }
 
-module.exports = { stageOverlay, stageRoot, readGatewayAlias }
+module.exports = { stageOverlay, stageRoot, readGatewayAlias, DEFAULT_JEV_PLUGIN_SPEC }

package/lib/status.js

@@ -24,6 +24,7 @@
 const fs = require("fs")
 
 const { elliotConfigPath } = require("./setup.js")
+const { billingContext } = require("./context.js")
 
 /** Read ~/.elliot/config.json, or null when absent/unreadable. */
 function readElliotConfig() {
@@ -107,6 +108,7 @@ async function runStatus(opts = {}) {
   log(`Workspace ID:  ${config.tenant_id || "(unknown)"}`)
   if (config.stack) log(`Stack:         ${config.stack}`)
   log(`Backend:       ${config.backend_url || "(unset)"}`)
+  log(`Billing:       ${billingContext(config).label}`)
 
   const healthy = config.backend_url ? await checkBackendHealth(config.backend_url) : false
   log(`Reachable:     ${healthy ? "yes" : "no"}`)

package/lib/teams.js

@@ -0,0 +1,233 @@
+"use strict"
+
+/**
+ * `eai teams` — list, select, verify and clear the team billing context.
+ *
+ * Approved model (docs/architecture/EAI_ONBOARDING_BILLING_AUDIT.md §4/§6):
+ * the BACKEND is the only authority for membership and for the budgeted
+ * credential. These commands never trust a client-supplied team id as proof
+ * of membership — `GET /teams` returns only the caller's authorized teams,
+ * and `teams use`/`teams clear` re-fetch `/onboarding/config` through the
+ * exact provisioning path `eai setup` uses, so the materialised `opencode.json`
+ * carries the correct team (or personal) budgeted LiteLLM key. Fail-closed:
+ * a revoked membership, unknown/ambiguous team, or missing budgeted
+ * credential aborts with an actionable message and no config change.
+ *
+ * Switching teams rematerialises configuration and requires a FRESH `eai`
+ * session — OpenCode cannot swap the embedded key mid-session, so in-flight
+ * requests keep their original billing context (audit §3, decision 3).
+ */
+
+const { ensureFreshAccessToken, authorizedGet } = require("./auth.js")
+const { runSetup } = require("./setup.js")
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+/** Unwrap a /teams response whether the backend returns a bare array or an
+ *  object with a `teams` key. */
+function teamsFromBody(body) {
+  if (Array.isArray(body)) return body
+  if (body && Array.isArray(body.teams)) return body.teams
+  return []
+}
+
+/** Fetch the caller's authorized teams (empty on failure). */
+async function fetchTeams(opts = {}) {
+  const session = await ensureFreshAccessToken(opts)
+  if (!session) return null
+  const { config } = session
+  if (!config.tenant_id) {
+    opts.log && opts.log("Your login has no tenant. Run `eai login` again.")
+    return null
+  }
+  const result = await authorizedGet(
+    `/teams?tenant_id=${encodeURIComponent(config.tenant_id)}`,
+    opts,
+  )
+  if (!result || !result.ok) return []
+  return teamsFromBody(result.body)
+}
+
+async function runTeamsList(opts = {}) {
+  const log = opts.log || ((s) => process.stdout.write(s + "\n"))
+  const teams = await fetchTeams(opts)
+  if (teams === null) return 1
+  if (!teams.length) {
+    log("No teams are available to you yet.")
+    log("Ask an administrator to add you to a team, or run `eai` to use individual billing.")
+    return 0
+  }
+  log("Your teams:")
+  for (const team of teams) {
+    const name = team.name || "(unnamed)"
+    const budget =
+      typeof team.max_budget_usd === "number" && team.max_budget_usd > 0
+        ? ` — budget $${team.max_budget_usd}/day`
+        : ""
+    log(`  ${name}${budget}  (${team.id})`)
+  }
+  log("")
+  log('Select one with:  eai teams use "<team name>"')
+  log("Show the active context with:  eai teams current")
+  return 0
+}
+
+/** Resolve a `teams use` argument to a single team id, or null (with a
+ *  message) when it is unknown or ambiguous. */
+function resolveTeamId(teams, arg) {
+  if (UUID_RE.test(arg)) {
+    const match = teams.find((t) => String(t.id) === arg)
+    if (match) return { id: String(match.id), name: match.name }
+    return null
+  }
+  const matches = teams.filter((t) => String(t.name) === arg)
+  if (matches.length === 1) {
+    return { id: String(matches[0].id), name: matches[0].name }
+  }
+  if (matches.length > 1) {
+    const list = matches.map((t) => `  ${t.name}  (${t.id})`).join("\n")
+    return {
+      ambiguous: true,
+      message:
+        `Multiple teams are named "${arg}". Use the id instead:\n${list}\n` +
+        '  eai teams use "<id>"',
+    }
+  }
+  return null
+}
+
+async function runTeamsUse(opts = {}) {
+  const log = opts.log || ((s) => process.stdout.write(s + "\n"))
+  const arg = String(opts.team || "").trim()
+  if (!arg) {
+    log('Usage: eai teams use "<team name or id>"')
+    return 1
+  }
+  const session = await ensureFreshAccessToken(opts)
+  if (!session) return 1
+  const { token, config } = session
+  const backendUrl = String(opts.backendUrl || config.backend_url || "").replace(/\/+$/, "")
+  if (!backendUrl) {
+    log("No backend configured. Run `eai login` first.")
+    return 1
+  }
+
+  const teams = await fetchTeams(opts)
+  if (teams === null) return 1
+  const resolved = resolveTeamId(teams, arg)
+  if (!resolved) {
+    log(`You are not a member of a team named or id'd "${arg}".`)
+    log("Run `eai teams` to see the teams available to you.")
+    return 1
+  }
+  if (resolved.ambiguous) {
+    log(resolved.message)
+    return 1
+  }
+
+  // Rematerialise through the exact setup path: the backend validates
+  // membership, resolves the TEAM's budgeted LiteLLM key (fail-closed if
+  // none resolves), and writes the config + opencode.json. A failure here
+  // leaves the previous config untouched.
+  log(`Selecting team "${resolved.name}"...`)
+  try {
+    await runSetup({ token, backendUrl, teamId: resolved.id, log })
+  } catch (error) {
+    log(String(error && error.message ? error.message : error))
+    log("Team selection did not change. Your previous billing context is unchanged.")
+    return 1
+  }
+  log("")
+  log(`Billing team set to "${resolved.name}".`)
+  log("Restart EAI (`eai`) to apply the new context. In-flight work is unaffected.")
+  return 0
+}
+
+async function runTeamsCurrent(opts = {}) {
+  const log = opts.log || ((s) => process.stdout.write(s + "\n"))
+  const session = await ensureFreshAccessToken(opts)
+  if (!session) return 1
+  const { config } = session
+
+  const displayUser = config.email || config.user_id || "(unknown)"
+  const teamId = config.team_id
+  const isTeam = Boolean(teamId)
+
+  // Verify server-side, not from local config alone: resolve the team from
+  // the authorized list (revoked membership => 404/absent => unverified).
+  let teamName = null
+  let verified = false
+  const teams = await fetchTeams(opts)
+  if (teams) {
+    if (isTeam) {
+      const team = teams.find((t) => String(t.id) === String(teamId))
+      if (team) {
+        teamName = team.name
+        verified = true
+      }
+    } else {
+      // Individual billing: verified as long as we can fetch the authorized
+      // list (i.e. the session is live and the caller is an identified user).
+      verified = true
+    }
+  }
+
+  log("Elliot AI context")
+  log("─────────────────────────────")
+  log(`Signed in: ${displayUser}`)
+  if (isTeam && teamName) {
+    log(`Billing:   Team — ${teamName}`)
+  } else if (isTeam && !teamName) {
+    log("Billing:   Team (name unavailable)")
+  } else {
+    log("Billing:   Individual")
+  }
+  log(`Status:    ${verified ? "Verified" : "Unverified — cannot confirm with the backend"}`)
+  if (isTeam) {
+    log("Action:    Restart EAI to apply the current context")
+  } else {
+    log("Action:    none — requests are charged to your individual budget")
+  }
+  log("")
+  return verified ? 0 : 1
+}
+
+async function runTeamsClear(opts = {}) {
+  const log = opts.log || ((s) => process.stdout.write(s + "\n"))
+  const session = await ensureFreshAccessToken(opts)
+  if (!session) return 1
+  const { token, config } = session
+  const backendUrl = String(opts.backendUrl || config.backend_url || "").replace(/\/+$/, "")
+  if (!backendUrl) {
+    log("No backend configured. Run `eai login` first.")
+    return 1
+  }
+
+  log("Clearing team selection — reverting to individual billing...")
+  try {
+    // No team_id => /onboarding/config resolves the caller's PERSONAL key
+    // (fail-closed if none resolves — never the shared master key).
+    await runSetup({ token, backendUrl, log })
+  } catch (error) {
+    log(String(error && error.message ? error.message : error))
+    log(
+      "Individual billing could not be established. Model execution stays " +
+        "blocked until a personal budgeted credential is available. Contact " +
+        "your administrator.",
+    )
+    return 1
+  }
+  log("")
+  log("Team selection cleared — billing is now Individual.")
+  log("Restart EAI (`eai`) to apply the new context.")
+  return 0
+}
+
+module.exports = {
+  fetchTeams,
+  resolveTeamId,
+  runTeamsList,
+  runTeamsUse,
+  runTeamsCurrent,
+  runTeamsClear,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliotsystems/eai",
-  "version": "0.1.7",
+  "version": "0.1.14",
   "description": "Elliot AI CLI entry point (eai) - launches the Elliot runtime with arguments forwarded verbatim.",
   "bin": {
     "eai": "./bin/eai"
@@ -27,6 +27,6 @@
     "access": "public"
   },
   "dependencies": {
-    "opencode-ai": "1.19.0"
+    "opencode-ai": "1.19.5"
   }
 }