@elliotsystems/eai 0.1.9 → 0.1.14

package/bin/eai

@@ -303,6 +303,13 @@ if (!env.OPENCODE_CONFIG_DIR) {
 // our own below. This is what lets OpenCode stay stock.
 env.OPENCODE_DISABLE_TERMINAL_TITLE = "1"
 
+// The TUI owns the whole terminal, so anything the runtime or a dependency prints
+// to stderr lands on top of the screen. Node's own runtime warnings are the common
+// case: `DEP0169 url.parse()` from a dependency printed three lines over the prompt
+// on every launch. Switched off unless the user set the variable themselves, so
+// `NODE_NO_WARNINGS=0` still brings them back when debugging.
+if (env.NODE_NO_WARNINGS === undefined) env.NODE_NO_WARNINGS = "1"
+
 // Claim the title before the child paints anything.
 if (process.stdout.isTTY) process.stdout.write(ELLIOT_TITLE)
 

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliotsystems/eai",
-  "version": "0.1.9",
+  "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.4"
+    "opencode-ai": "1.19.5"
   }
 }

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/guardrail-sync.ts

@@ -99,6 +99,10 @@ interface CacheEntry {
   jevPolicyEnabled: boolean
   /** Jev audit (2026-10, G2). */
   jevOutputValidationEnabled: boolean
+  /** Fast Jev Compaction pilot (spec: `specs/2026-10-29-fast-jev-
+   *  compaction-pilot.md`, task T7) -- `Team.eai_compaction_enabled`, read
+   *  from this SAME `GET /teams/{id}` response, never a second round trip. */
+  compactionEnabled: boolean
   teamId: string
   expiresAt: number
 }
@@ -159,10 +163,14 @@ export interface LiveCheckDeps {
  * all). Returns `null` under the exact same conditions `liveJevPolicyEnabled`
  * always has (see its own docstring, preserved below) — no team context, an
  * instance/request team-id mismatch, or a failed check with no usable cache.
+ *
+ * Fast Jev Compaction pilot (T7): also reads `eai_compaction_enabled` from
+ * this same response/cache entry -- one more field off a call this module
+ * already makes, not a second network round trip.
  */
 async function liveJevGuardrailFlags(
   deps: LiveCheckDeps = {},
-): Promise<{ jevPolicyEnabled: boolean; jevOutputValidationEnabled: boolean } | null> {
+): Promise<{ jevPolicyEnabled: boolean; jevOutputValidationEnabled: boolean; compactionEnabled: boolean } | null> {
   const now = deps.now ?? Date.now
   const fetchImpl = deps.fetchImpl ?? fetch
   const readConfig = deps.readConfig ?? readElliotConfig
@@ -191,7 +199,11 @@ async function liveJevGuardrailFlags(
   }
 
   if (cache && cache.teamId === config.team_id && now() < cache.expiresAt) {
-    return { jevPolicyEnabled: cache.jevPolicyEnabled, jevOutputValidationEnabled: cache.jevOutputValidationEnabled }
+    return {
+      jevPolicyEnabled: cache.jevPolicyEnabled,
+      jevOutputValidationEnabled: cache.jevOutputValidationEnabled,
+      compactionEnabled: cache.compactionEnabled,
+    }
   }
 
   const controller = new AbortController()
@@ -207,13 +219,15 @@ async function liveJevGuardrailFlags(
     const record = body && typeof body === "object" ? (body as Record<string, unknown>) : {}
     const jevPolicyEnabled = Boolean(record.jev_policy_enabled)
     const jevOutputValidationEnabled = Boolean(record.jev_output_validation_enabled)
+    const compactionEnabled = Boolean(record.eai_compaction_enabled)
     cache = {
       jevPolicyEnabled,
       jevOutputValidationEnabled,
+      compactionEnabled,
       teamId: config.team_id,
       expiresAt: now() + CACHE_TTL_MS,
     }
-    return { jevPolicyEnabled, jevOutputValidationEnabled }
+    return { jevPolicyEnabled, jevOutputValidationEnabled, compactionEnabled }
   } catch {
     // Offline, backend unreachable, expired token, or a malformed response.
     // Never throw into the chat.params hook over this -- a CLI message must
@@ -221,7 +235,11 @@ async function liveJevGuardrailFlags(
     // to a still-fresh cached value for this same team if one exists;
     // otherwise genuinely unknown.
     return cache && cache.teamId === config.team_id && now() < cache.expiresAt
-      ? { jevPolicyEnabled: cache.jevPolicyEnabled, jevOutputValidationEnabled: cache.jevOutputValidationEnabled }
+      ? {
+          jevPolicyEnabled: cache.jevPolicyEnabled,
+          jevOutputValidationEnabled: cache.jevOutputValidationEnabled,
+          compactionEnabled: cache.compactionEnabled,
+        }
       : null
   } finally {
     clearTimeout(timer)
@@ -253,6 +271,28 @@ export async function liveJevOutputValidationEnabled(deps: LiveCheckDeps = {}):
   return flags ? flags.jevOutputValidationEnabled : null
 }
 
+/**
+ * Fast Jev Compaction pilot (spec: `specs/2026-10-29-fast-jev-compaction-
+ * pilot.md`, task T7) — the team's current `Team.eai_compaction_enabled`,
+ * live from the backend, with the exact same `null`-means-"leave it alone"
+ * contract as `liveJevPolicyEnabled`/`liveJevOutputValidationEnabled`.
+ * Shares the same cached `GET /teams/{id}` call under the hood, so calling
+ * this alongside either (or both) of the other two costs at most one
+ * network round trip, not two or three.
+ *
+ * Callers (index.ts's `experimental.chat.messages.transform` hook) must
+ * treat `null` and `false` identically here: skip compaction and leave
+ * `output.messages` exactly as `stripBlockedTurns` left them. Unlike the
+ * Jev guardrails, there is no security-load-bearing reason to fail closed
+ * on uncertainty -- this flag only decides whether a token-reduction pass
+ * runs at all, so "do nothing" is always the safe default when the answer
+ * is not confidently known.
+ */
+export async function liveCompactionEnabled(deps: LiveCheckDeps = {}): Promise<boolean | null> {
+  const flags = await liveJevGuardrailFlags(deps)
+  return flags ? flags.compactionEnabled : null
+}
+
 /**
  * Applies a live guardrail decision to the outgoing request's `options`,
  * mutating `metadata.guardrails` to match exactly — adding `guardrailName`

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

@@ -27,12 +27,22 @@ import { resolveEndUserId, type SessionClient } from "./identity-headers.js"
 import {
   applyGuardrailDecision,
   extractInstanceTeamId,
+  liveCompactionEnabled,
   liveJevOutputValidationEnabled,
   liveJevPolicyEnabled,
   OUTPUT_VALIDATION_GUARDRAIL_NAME,
 } from "./guardrail-sync.js"
-import { stampSessionAffinity } from "./session-affinity.js"
+import { stampSessionAffinity, type CompactionTelemetry } from "./session-affinity.js"
 import { stripBlockedTurns } from "./blocked-turns.js"
+import { readElliotConfig } from "./elliot-auth.js"
+import {
+  compactMessages,
+  type AskerAnswer,
+  type AskerContext,
+  type CompactionMessage,
+  type ContentBlock,
+  type MessageRole,
+} from "./compaction.js"
 
 // Structural mirrors of the host types (packages/plugin/src/index.ts @
 // v1.18.19). Declared locally so this package type-checks and unit-tests
@@ -125,6 +135,256 @@ export interface Hooks {
 
 export type Plugin = (input: PluginInput, options?: Record<string, unknown>) => Promise<Hooks>
 
+// ---------------------------------------------------- compaction adapter --
+//
+// Fast Jev Compaction pilot (spec: `specs/2026-10-29-fast-jev-compaction-
+// pilot.md`, task T7). `compaction.ts` (T6) is deliberately transport- and
+// host-shape-agnostic: it only knows its own `CompactionMessage`/
+// `ContentBlock` shape. Everything below adapts OpenCode's native history
+// entry shape (`{ info, parts }`, the same one `blocked-turns.ts` reads) to
+// and from that shape, and supplies the `asker` that calls the T3 backend
+// proxy. None of this runs unless `liveCompactionEnabled` resolves `true`,
+// and the whole attempt is wrapped in a single try/catch in the hook below
+// so a bad response, a network failure, or a bug in this adapter can never
+// break or delay a chat turn -- it only ever falls back to whatever
+// `stripBlockedTurns` already produced.
+
+/** Per-request timeout for one `keepCall`/`keepResult` judge call. Several
+ *  of these may run per turn (one per candidate tool round trip); kept
+ *  short so a hung backend cannot meaningfully delay a chat turn even
+ *  before the outer try/catch gives up on compaction entirely. */
+const COMPACTION_ASKER_TIMEOUT_MS = 5_000
+
+interface NativeToolPartState {
+  status?: unknown
+  input?: unknown
+  output?: unknown
+  error?: unknown
+  [k: string]: unknown
+}
+
+interface NativeToolPart {
+  type: "tool"
+  tool?: unknown
+  callID?: unknown
+  state?: NativeToolPartState
+  [k: string]: unknown
+}
+
+type NativePart = { type?: unknown; text?: unknown } & Record<string, unknown>
+
+interface NativeMessage {
+  info?: Record<string, unknown>
+  parts?: unknown[]
+}
+
+function nativeMessageRole(info: Record<string, unknown> | undefined): MessageRole {
+  if (info?.["role"] === "assistant") return "assistant"
+  if (info?.["role"] === "system") return "system"
+  return "user"
+}
+
+interface CompactionAdapterState {
+  readonly compactionMessages: CompactionMessage[]
+  /** Original native tool part per `callID`, used on the way back to
+   *  restore everything compaction never needed to know about (metadata,
+   *  attachments, timing) rather than rebuilding it from scratch. */
+  readonly toolPartsByCallId: Map<string, NativeToolPart>
+  /** Parts compaction has no vocabulary for (reasoning, step-start, etc.),
+   *  keyed by the message's own `info` object reference -- `compaction.ts`
+   *  carries `info` through unchanged on every surviving `CompactionMessage`
+   *  (see its own module docstring), so looking it back up by identity is
+   *  reliable regardless of what compaction dropped or kept. */
+  readonly passthroughPartsByInfo: Map<object, unknown[]>
+}
+
+/** Converts OpenCode's native `{ info, parts }` history entries into T6's
+ *  `CompactionMessage` shape. A native "tool" part (OpenCode pairs the call
+ *  and its result into ONE part, unlike Claude-style `tool_use`/
+ *  `tool_result` content blocks) becomes a `tool_use` block immediately
+ *  followed, in the SAME message, by a `tool_result` block once the call has
+ *  actually completed or errored -- `compaction.ts`'s pairing logic matches
+ *  blocks by id regardless of which message(s) they live in, so this is a
+ *  faithful, simpler-than-splitting-messages encoding. */
+function toCompactionMessages(nativeMessages: readonly NativeMessage[]): CompactionAdapterState {
+  const compactionMessages: CompactionMessage[] = []
+  const toolPartsByCallId = new Map<string, NativeToolPart>()
+  const passthroughPartsByInfo = new Map<object, unknown[]>()
+
+  for (const native of nativeMessages) {
+    const info = native.info
+    const role = nativeMessageRole(info)
+    const blocks: ContentBlock[] = []
+    const passthrough: unknown[] = []
+
+    for (const rawPart of native.parts ?? []) {
+      const part = rawPart as NativePart
+      if (part.type === "text" && typeof part.text === "string") {
+        blocks.push({ type: "text", text: part.text })
+        continue
+      }
+      if (part.type === "tool" && typeof part.callID === "string") {
+        const toolPart = part as NativeToolPart
+        const callId = part.callID
+        toolPartsByCallId.set(callId, toolPart)
+        blocks.push({
+          type: "tool_use",
+          id: callId,
+          name: typeof toolPart.tool === "string" ? toolPart.tool : "unknown",
+          input: toolPart.state?.input,
+        })
+        const status = toolPart.state?.status
+        if (status === "completed" || status === "error") {
+          const output = toolPart.state?.output
+          const errorValue = toolPart.state?.error
+          const content =
+            typeof output === "string"
+              ? output
+              : typeof errorValue === "string"
+                ? errorValue
+                : JSON.stringify(output ?? errorValue ?? "")
+          blocks.push({ type: "tool_result", tool_use_id: callId, content })
+        }
+        continue
+      }
+      passthrough.push(rawPart)
+    }
+
+    if (passthrough.length > 0 && info) passthroughPartsByInfo.set(info, passthrough)
+    compactionMessages.push({ role, content: blocks, info: info as CompactionMessage["info"] })
+  }
+
+  return { compactionMessages, toolPartsByCallId, passthroughPartsByInfo }
+}
+
+/** Reverses `toCompactionMessages`, rebuilding native `{ info, parts }`
+ *  entries from T6's output. A kept pair's native tool part is reused
+ *  verbatim (preserving fields compaction never touched); a truncated
+ *  pair's part is cloned with only `state.output` replaced by the short
+ *  "omitted" note `compaction.ts` already produced; a dropped pair simply
+ *  never gets a part emitted. */
+function fromCompactionMessages(
+  compactionMessages: readonly CompactionMessage[],
+  toolPartsByCallId: ReadonlyMap<string, NativeToolPart>,
+  passthroughPartsByInfo: ReadonlyMap<object, unknown[]>,
+): NativeMessage[] {
+  return compactionMessages.map((message) => {
+    const parts: unknown[] = []
+
+    if (typeof message.content === "string") {
+      if (message.content) parts.push({ type: "text", text: message.content })
+    } else {
+      for (const block of message.content) {
+        if (block.type === "text") {
+          parts.push({ type: "text", text: block.text })
+          continue
+        }
+        if (block.type === "tool_use") {
+          const original = toolPartsByCallId.get(block.id)
+          if (original) {
+            parts.push({
+              ...original,
+              state: original.state ? { ...original.state, input: block.input } : original.state,
+            })
+          }
+          continue
+        }
+        if (block.type === "tool_result") {
+          // Merge into the tool part this same loop just pushed for the
+          // matching `tool_use` -- `compaction.ts` always keeps a call's
+          // block immediately before its result's within one message (see
+          // `toCompactionMessages`), so it is always the last entry here.
+          const lastIndex = parts.length - 1
+          const last = parts[lastIndex] as NativeToolPart | undefined
+          if (last && last.type === "tool" && last.callID === block.tool_use_id) {
+            parts[lastIndex] = { ...last, state: { ...last.state, output: block.content } }
+          }
+          continue
+        }
+      }
+    }
+
+    const passthrough = message.info ? passthroughPartsByInfo.get(message.info) : undefined
+    if (passthrough) parts.push(...passthrough)
+
+    return { info: message.info as Record<string, unknown> | undefined, parts }
+  })
+}
+
+/**
+ * The T3 proxy's own request/response contract, independent of whatever
+ * OpenRouter's Decisions API itself returns -- T3 treats both `state` and
+ * `questions` as opaque and passes `body` straight through, so this plugin
+ * (the only side that understands the payload) defines the convention: one
+ * question per `asker` call, answered as `{ answers: [{ keepCall,
+ * keepResult }] }`. Any other shape is treated as "could not get an answer"
+ * and throws, which the outer try/catch in the hook below turns into
+ * "skip compaction entirely for this turn" -- never a partial, wrongly-
+ * judged compaction.
+ */
+function parseDecisionAnswer(body: unknown): AskerAnswer {
+  const record = body && typeof body === "object" ? (body as Record<string, unknown>) : null
+  const answers = record && Array.isArray(record["answers"]) ? record["answers"] : null
+  const first = answers && answers.length > 0 ? answers[0] : null
+  const firstRecord = first && typeof first === "object" ? (first as Record<string, unknown>) : null
+  const keepCall = firstRecord ? Number(firstRecord["keepCall"]) : NaN
+  const keepResult = firstRecord ? Number(firstRecord["keepResult"]) : NaN
+  if (!Number.isFinite(keepCall) || !Number.isFinite(keepResult)) {
+    throw new Error("compaction decisions response did not contain a usable answer")
+  }
+  return { keepCall, keepResult }
+}
+
+/** Builds the `Asker` the T7 wiring passes to `compactMessages`: one POST to
+ *  the T3 endpoint (`POST /opencode/teams/{team_id}/compaction/decisions`)
+ *  per candidate tool round trip, reusing the exact fetch/auth pattern
+ *  `guardrail-sync.ts` already uses for its own backend call (bearer JWT,
+ *  `~/.elliot/config.json`'s `backend_url`/`team_id`, an `AbortController`-
+ *  based timeout). Throws on ANY failure -- offline, non-2xx, `available:
+ *  false`, or an unparseable body -- by design: the caller (the hook below)
+ *  wraps the whole compaction attempt in one try/catch, so a single bad
+ *  answer here safely aborts compaction for this turn rather than risking a
+ *  wrongly-judged partial result. */
+function makeCompactionAsker(config: {
+  backendUrl: string
+  teamId: string
+  jwtToken: string
+  fetchImpl?: typeof fetch
+}): (context: AskerContext) => Promise<AskerAnswer> {
+  const fetchImpl = config.fetchImpl ?? fetch
+  const base = config.backendUrl.replace(/\/+$/, "")
+
+  return async (context: AskerContext): Promise<AskerAnswer> => {
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), COMPACTION_ASKER_TIMEOUT_MS)
+    try {
+      const res = await fetchImpl(`${base}/opencode/teams/${encodeURIComponent(config.teamId)}/compaction/decisions`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${config.jwtToken}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          state: context.state,
+          questions: [
+            { id: context.id, toolName: context.toolName, input: context.input, resultSummary: context.resultSummary },
+          ],
+        }),
+        signal: controller.signal,
+      })
+      if (!res.ok) throw new Error(`backend returned ${res.status}`)
+      const payload: unknown = await res.json()
+      const record = payload && typeof payload === "object" ? (payload as Record<string, unknown>) : {}
+      if (record["available"] !== true) {
+        throw new Error(typeof record["reason"] === "string" ? record["reason"] : "compaction decisions unavailable")
+      }
+      return parseDecisionAnswer(record["body"])
+    } finally {
+      clearTimeout(timer)
+    }
+  }
+}
+
 export const ElliotPlugin: Plugin = async (input, rawOptions) => {
   // Fail loudly at load on bad options — a plugin that limps with a typo'd
   // config is worse than one that says why it refused to start.
@@ -134,6 +394,47 @@ export const ElliotPlugin: Plugin = async (input, rawOptions) => {
   // the one source the model cannot influence.
   const worktree = input.worktree || input.directory
 
+  // Fast Jev Compaction pilot (spec: `specs/2026-10-29-fast-jev-compaction-
+  // pilot.md`, task T9). `experimental.chat.messages.transform` is triggered
+  // with an EMPTY `hookInput` (session/prompt.ts), so the compaction outcome
+  // it produces can't be correlated to a session id from inside that hook.
+  // `chat.params` -- which DOES get `hookInput.sessionID` and already stamps
+  // `metadata.session_id` via `stampSessionAffinity` -- fires immediately
+  // after, for the SAME turn (session/llm/request.ts builds `chat.params`
+  // from the same `msgs` the transform hook just finished mutating).
+  //
+  // A FIFO QUEUE, not a single mutable slot (code-review finding, post-T9):
+  // this plugin instance is a process-wide singleton, and both hooks are
+  // `async` -- if two sessions' turns are ever in flight concurrently (very
+  // plausible once a turn's compaction attempt awaits a live-flag check plus
+  // one network round trip per stale tool-call candidate), a single shared
+  // slot lets a slower session A's `transform` overwrite what a faster
+  // session B's `transform` just set, before B's own `chat.params` reads it
+  // -- silently mislabeling B's `LiteLLM_SpendLogs` row with A's telemetry
+  // (or vice versa), which directly undermines the before/after cost
+  // comparison T9 exists for. A FIFO queue fixes this without needing a
+  // session id in the transform hook at all: each session's own
+  // `transform`-then-`params` pair is internally ordered (params always
+  // fires after that same turn's transform), so across interleaved
+  // sessions the order in which `transform` calls finish and push still
+  // matches the order in which the corresponding `chat.params` calls fire
+  // and shift -- unlike a single slot, this doesn't require the two calls
+  // to be adjacent in time, only in queue order.
+  const pendingCompactionTelemetryQueue: CompactionTelemetry[] = []
+
+  // Wall-clock budget for the ENTIRE compaction attempt (code-review
+  // finding, post-T7): `compactMessages` awaits one `asker` call per
+  // non-pinned tool-call candidate, sequentially, each already bounded by
+  // `COMPACTION_ASKER_TIMEOUT_MS` -- but nothing previously bounded the
+  // SUM across many candidates. A turn with N stale candidates could add up
+  // to N * COMPACTION_ASKER_TIMEOUT_MS of latency before the outer
+  // try/catch below ever got a chance to fail open (that catch only fires
+  // on a thrown error, not on cumulative slowness), undercutting "this
+  // feature must never be able to break or delay a chat turn." This budget
+  // is enforced by racing the whole `compactMessages` call against a timer
+  // below, not by changing `compactMessages` itself.
+  const COMPACTION_TURN_BUDGET_MS = 15_000
+
   return {
     /**
      * One handler, two jobs — a JS object literal may carry only one
@@ -216,9 +517,81 @@ export const ElliotPlugin: Plugin = async (input, rawOptions) => {
      */
     "experimental.chat.messages.transform": async (_hookInput, output) => {
       const filtered = stripBlockedTurns(output.messages)
-      if (filtered === output.messages) return
-      output.messages.length = 0
-      output.messages.push(...filtered)
+      if (filtered !== output.messages) {
+        output.messages.length = 0
+        output.messages.push(...filtered)
+      }
+
+      // Fast Jev Compaction pilot (spec: `specs/2026-10-29-fast-jev-
+      // compaction-pilot.md`, task T7). Runs strictly AFTER `stripBlockedTurns`
+      // above -- compaction must never see a message that was already known
+      // to be a blocked turn `stripBlockedTurns` would otherwise have
+      // removed. Opt-in (`liveCompactionEnabled`) and entirely fail-open: a
+      // `null`/`false` decision, or ANY error/timeout from the live check,
+      // the adapter, or the backend call the `asker` makes, leaves
+      // `output.messages` exactly as `stripBlockedTurns` left them above --
+      // this feature must never be able to break or delay a chat turn,
+      // mirroring guardrail-sync.ts's own fail-open posture (see its module
+      // docstring) rather than the Jev guardrails' own fail-closed one,
+      // since this flag only decides whether a token-reduction pass runs at
+      // all, not a security boundary.
+      // This turn's own outcome, pushed onto the FIFO queue (see its
+      // declaration above) exactly once below -- every path (flag off,
+      // missing config, success, timeout, or the catch's fail-open) pushes
+      // before returning, so `chat.params` always has exactly one entry per
+      // turn to shift, in the same relative order these pushes happened.
+      let telemetry: CompactionTelemetry = { applied: false }
+      try {
+        const compactionDecision = await liveCompactionEnabled()
+        if (compactionDecision !== true) return
+
+        const config = readElliotConfig()
+        if (!config?.backend_url || !config.team_id || !config.jwt_token) return
+
+        const { compactionMessages, toolPartsByCallId, passthroughPartsByInfo } = toCompactionMessages(
+          output.messages as unknown as NativeMessage[],
+        )
+
+        const asker = makeCompactionAsker({
+          backendUrl: config.backend_url,
+          teamId: config.team_id,
+          jwtToken: config.jwt_token,
+        })
+
+        // Raced against COMPACTION_TURN_BUDGET_MS (see its declaration
+        // above) -- a turn with many stale candidates can't accumulate
+        // unbounded latency across sequential asker calls. A timeout here
+        // throws into the same catch below as any other failure, so the
+        // fail-open behavior is identical either way.
+        const result = await Promise.race([
+          compactMessages(compactionMessages, { asker }),
+          new Promise<never>((_resolve, reject) => {
+            setTimeout(() => reject(new Error("compaction turn budget exceeded")), COMPACTION_TURN_BUDGET_MS)
+          }),
+        ])
+        const rebuilt = fromCompactionMessages(result.messages, toolPartsByCallId, passthroughPartsByInfo)
+
+        output.messages.length = 0
+        output.messages.push(...(rebuilt as typeof output.messages))
+
+        // T9 telemetry: surface T6's own already-computed stats verbatim --
+        // no new computation -- for `chat.params` to stamp into
+        // `metadata.compaction_applied`/`compaction_state_tokens`/
+        // `compaction_reduction_ratio` via `stampSessionAffinity`.
+        telemetry = {
+          applied: true,
+          stateTokens: result.stats.stateTokens,
+          reductionRatio: result.stats.reductionRatio,
+        }
+      } catch {
+        // Any failure anywhere in the attempt above (live-flag check,
+        // adapter, the asker's HTTP call, compactMessages itself, or the
+        // turn-budget timeout) -- do nothing. `output.messages` already
+        // reflects whatever `stripBlockedTurns` produced; leave it exactly
+        // as is. `telemetry` stays `{ applied: false }` (T9).
+      } finally {
+        pendingCompactionTelemetryQueue.push(telemetry)
+      }
     },
 
     /**
@@ -264,7 +637,13 @@ export const ElliotPlugin: Plugin = async (input, rawOptions) => {
      * costs at most one network round trip, not two.
      */
     "chat.params": async (hookInput, output) => {
-      stampSessionAffinity(output.options, hookInput.sessionID)
+      // T9: shift this turn's entry off the FIFO queue `experimental.chat.
+      // messages.transform` pushed for it (see the queue's declaration
+      // above). `shift()` on an empty queue (a turn that skipped the
+      // transform hook entirely) yields `undefined`, defaulted below --
+      // never a stale value from a different turn.
+      const compactionTelemetry = pendingCompactionTelemetryQueue.shift() ?? { applied: false }
+      stampSessionAffinity(output.options, hookInput.sessionID, compactionTelemetry)
       const instanceTeamId = extractInstanceTeamId(output.options)
       const preCallDecision = await liveJevPolicyEnabled({ instanceTeamId })
       applyGuardrailDecision(output.options, preCallDecision)

package/plugin/opencode-plugin/src/session-affinity.ts

@@ -21,16 +21,39 @@
  * unchanged pre-existing request still goes out).
  */
 
+/**
+ * Fast Jev Compaction pilot (spec: `specs/2026-10-29-fast-jev-compaction-
+ * pilot.md`, task T9) telemetry handed to `stampSessionAffinity` alongside
+ * the session id, so a before/after cost comparison can later be built
+ * purely from `LiteLLM_SpendLogs` metadata filtered by `session_id` and
+ * `compaction_applied` (see `litellm_spend.py`'s existing per-request
+ * `prompt_tokens`/`completion_tokens` fields) -- no new computation here,
+ * these are T6's own `CompactionStats` fields, surfaced as-is.
+ */
+export interface CompactionTelemetry {
+  readonly applied: boolean
+  readonly stateTokens?: number
+  readonly reductionRatio?: number
+}
+
 /**
  * Stamp the OpenCode session id into a request's `metadata.session_id` so
  * LiteLLM can route every turn of the same session to the same deployment.
  * `options` is the same merged options object `chat.params` hands the caller
  * (`opencode/.../session/llm/request.ts`), the one `metadata.guardrails`
  * already travels in.
+ *
+ * Also stamps `metadata.compaction_applied` (T9) -- `false`, with
+ * `compaction_state_tokens`/`compaction_reduction_ratio` absent, whenever
+ * `compaction` is omitted or `compaction.applied` is `false` (flag off, or
+ * the compaction attempt in `experimental.chat.messages.transform` failed
+ * open); `true` plus both numeric fields when it actually ran and produced
+ * a result.
  */
 export function stampSessionAffinity(
   options: Record<string, unknown> | null | undefined,
   sessionID: string | undefined,
+  compaction?: CompactionTelemetry,
 ): void {
   if (!options || typeof options !== "object" || !sessionID) return
   const metadata =
@@ -38,4 +61,13 @@ export function stampSessionAffinity(
       ? (options.metadata as Record<string, unknown>)
       : (options.metadata = {} as Record<string, unknown>)
   metadata["session_id"] = sessionID
+
+  metadata["compaction_applied"] = compaction?.applied ?? false
+  if (compaction?.applied) {
+    metadata["compaction_state_tokens"] = compaction.stateTokens
+    metadata["compaction_reduction_ratio"] = compaction.reductionRatio
+  } else {
+    delete metadata["compaction_state_tokens"]
+    delete metadata["compaction_reduction_ratio"]
+  }
 }