feat: collapse/float compaction modes and knowledge pack support

Collapse compaction mode:
- Selectively compresses oldest 65% of tokens instead of entire conversation
- Merges historical summaries for continuity (configurable: previousSummaries)
- Places summary at correct breakpoint position in timeline
- TUI toggle cycles standard -> collapse -> float via command palette
- insertTriggers=false prevents timestamp collision infinite loops
- Preserves real user messages; only deletes synthetic trigger messages

Float compaction mode:
- Sub-collapses oldest conversation chains before overflow evaluation
- Chain detection requires 2+ assistant messages (skips simple Q&A pairs)
- bookend algorithm by default; configurable per chainThreshold
- Soft-deletes sub-collapsed messages with flux=compacted (not hard-delete)
- summary:true flag on sub-collapse result prevents re-trigger loops
- detectChains skips already-processed messages (summary:true or flux set)
  to prevent infinite sub-collapse loop
- Token adjustment accounts for sub-collapse savings to prevent re-trigger
- Reloads TUI messages after sub-collapse via session.compacted event
- Re-parents orphaned chain messages after mid-chain split
- splitChainMinThreshold gate prevents processing chains too small for benefit
- minFloat threshold: skip sub-collapse until total tokens reach configurable limit
- Float pre-check also fires on stop finish (not just before LLM calls)

Knowledge pack support:
- New KnowledgePack module for injecting knowledge pack messages into sessions
- Knowledge pack messages sit at time_created=1,2,... (before compaction breakpoints)
  and are prepended explicitly at prompt build time (filterCompacted never sees them)
- Propagates manually-enabled knowledge packs from parent to subagent sessions
- Knowledge pack agent prompt overrides: KP can declare agent.<name>.prompt to
  replace a built-in agent system prompt for the session (global registry not mutated)
- Plugin transform hook receives knowledge pack messages via toModelMessages injection
- TUI sidebar: add/remove knowledge packs, mirror to project config on change
- Server routes: /knowledge-pack list/add/remove/enable/disable endpoints
- Sidebar click race condition fix: refetchActive deferred after server response
- Sidebar prompt refocus: restores focus after KP interactions only
- Global knowledge packs mirrored to project config on sidebar add/remove
- Project config written to .opencode/opencode.json (not config.json)

Upstream overflow (413) integration:
- Collapse/float modes propagate overflow=true through to the continuation message:
  when a 413 triggers compaction in collapse or float mode, an overflow explanation
  message is injected after the collapse completes so the user understands their
  media attachments were too large
- filterCompacted: errored summary messages no longer treated as valid compaction
  breakpoints (upstream guard: !msg.info.error)
- filterCompacted: breakpoint detection no longer requires finish flag on assistant
  summary (collapse compaction may complete without setting finish)

Implementation details:
- compaction-extension.ts: self-contained for easy rebasing; all debug logging
  uses COLLAPSE tag (grep: tail -f ~/.local/share/opencode/log/dev.log | grep COLLAPSE)
- detectChains: handles mid-run user interjections in full chain detection
- copyUserMessage: inserts duplicate chain anchor when mid-chain compaction splits
  leave orphaned assistant messages
- Identifier.insertCopy / Identifier.insert: generate IDs that sort between
  existing messages without timestamp collisions
- isOverflow routes to CompactionExtension for collapse/float modes (configurable trigger)
- Config schema: compaction.method, extractRatio, recentRatio, summaryMaxTokens,
  previousSummaries, splitChain, splitChainMinThreshold, minFloat, insertTriggers
- knowledge.enabled, knowledge.paths, knowledge.packs config fields

Author: Ryan Wyler

packages/opencode/src/cli/cmd/tui/context/sync.tsx

@@ -103,6 +103,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
     })
 
     const sdk = useSDK()
+    const fullSyncedSessions = new Set<string>()
 
     sdk.event.listen((e) => {
       const event = e.details
@@ -194,6 +195,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
           break
 
         case "session.deleted": {
+          if (!store.session) break
           const result = Binary.search(store.session, event.properties.info.id, (s) => s.id)
           if (result.found) {
             setStore(
@@ -206,6 +208,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
           break
         }
         case "session.updated": {
+          if (!store.session) break
           const result = Binary.search(store.session, event.properties.info.id, (s) => s.id)
           if (result.found) {
             setStore("session", result.index, reconcile(event.properties.info))
@@ -225,6 +228,23 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
           break
         }
 
+        case "session.compacted": {
+          // Compaction modified messages, invalidate cache and reload
+          const sessionID = event.properties.sessionID
+          fullSyncedSessions.delete(sessionID)
+          sdk.client.session.messages({ sessionID, limit: 100 }).then((messages) => {
+            setStore(
+              produce((draft) => {
+                draft.message[sessionID] = messages.data!.map((x) => x.info)
+                for (const message of messages.data!) {
+                  draft.part[message.info.id] = message.parts
+                }
+              }),
+            )
+          })
+          break
+        }
+
         case "message.updated": {
           const messages = store.message[event.properties.info.sessionID]
           if (!messages) {
@@ -266,6 +286,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
         }
         case "message.removed": {
           const messages = store.message[event.properties.sessionID]
+          if (!messages) break
           const result = Binary.search(messages, event.properties.messageID, (m) => m.id)
           if (result.found) {
             setStore(
@@ -319,6 +340,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
 
         case "message.part.removed": {
           const parts = store.part[event.properties.messageID]
+          if (!parts) break
           const result = Binary.search(parts, event.properties.partID, (p) => p.id)
           if (result.found)
             setStore(
@@ -431,7 +453,6 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       bootstrap()
     })
 
-    const fullSyncedSessions = new Set<string>()
     const result = {
       data: store,
       set: setStore,

packages/opencode/src/cli/cmd/tui/routes/session/index.tsx

@@ -159,6 +159,10 @@ export function Session() {
   const [diffWrapMode] = kv.signal<"word" | "none">("diff_wrap_mode", "word")
   const [animationsEnabled, setAnimationsEnabled] = kv.signal("animations_enabled", true)
   const [showGenericToolOutput, setShowGenericToolOutput] = kv.signal("generic_tool_output_visibility", false)
+  const [compactionMethod, setCompactionMethod] = kv.signal<"standard" | "collapse" | "float">(
+    "compaction_method",
+    sync.data.config.compaction?.method ?? "standard",
+  )
 
   const wide = createMemo(() => dimensions().width > 120)
   const sidebarVisible = createMemo(() => {
@@ -465,6 +469,19 @@ export function Session() {
         dialog.clear()
       },
     },
+    {
+      title: `Compaction: ${compactionMethod()} -> ${compactionMethod() === "standard" ? "collapse" : compactionMethod() === "collapse" ? "float" : "standard"}`,
+      value: "session.toggle.compaction_method",
+      category: "Session",
+      onSelect: (dialog) => {
+        setCompactionMethod((prev) => {
+          if (prev === "standard") return "collapse"
+          if (prev === "collapse") return "float"
+          return "standard"
+        })
+        dialog.clear()
+      },
+    },
     {
       title: "Unshare session",
       value: "session.unshare",

packages/opencode/src/cli/cmd/tui/routes/session/sidebar.tsx

@@ -1,5 +1,5 @@
 import { useSync } from "@tui/context/sync"
-import { createMemo, For, Show, Switch, Match } from "solid-js"
+import { createMemo, createResource, createSignal, For, Show, Switch, Match } from "solid-js"
 import { createStore } from "solid-js/store"
 import { useTheme } from "../../context/theme"
 import { Locale } from "@/util/locale"
@@ -11,9 +11,12 @@ import { useKeybind } from "../../context/keybind"
 import { useDirectory } from "../../context/directory"
 import { useKV } from "../../context/kv"
 import { TodoItem } from "../../component/todo-item"
+import { useSDK } from "@tui/context/sdk"
+import { usePromptRef } from "../../context/prompt"
 
 export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
   const sync = useSync()
+  const sdk = useSDK()
   const { theme } = useTheme()
   const session = createMemo(() => sync.session.get(props.sessionID)!)
   const diff = createMemo(() => sync.data.session_diff[props.sessionID] ?? [])
@@ -60,6 +63,77 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
     }
   })
 
+  type KPEntry = { id?: string; name: string; displayName: string; version: string; enabled: boolean }
+
+  // Whether the KP section is expanded to show all available packs
+  // Default true: new sessions show the full library so users can add packs immediately
+  const [kpExpanded, setKpExpanded] = createSignal(true)
+
+  // sdk transport helper — routes through Unix socket, not bare fetch
+  const sdkGet = (url: string, path: Record<string, string>) => (sdk.client as any).client.get({ url, path })
+  const sdkPost = (url: string, path: Record<string, string>) => (sdk.client as any).client.post({ url, path })
+  const sdkDelete = (url: string, path: Record<string, string>) => (sdk.client as any).client.delete({ url, path })
+
+  // Count of knowledge-pack messages in the sync store — changes whenever the server
+  // injects or removes a KP (message.updated / message.removed events), driving a refetch.
+  const kpMessageCount = createMemo(
+    () => (sync.data.message[props.sessionID] ?? []).filter((m) => (m as any).flux === "knowledge").length,
+  )
+
+  // When collapsed: fetch only active packs (fast, session-scoped)
+  const [activePacks, { refetch: refetchActive }] = createResource(
+    () => ({ sessionID: props.sessionID, kpCount: kpMessageCount() }),
+    async ({ sessionID }) => {
+      const res = await sdkGet("/session/{sessionID}/knowledge-packs", { sessionID })
+      if (res.error) return [] as KPEntry[]
+      return (res.data as { id: string; name: string; displayName: string; version?: string }[]).map(
+        (p) => ({ ...p, enabled: true }) as KPEntry,
+      )
+    },
+  )
+
+  // When expanded: fetch all available packs with enabled flag (reads library dir).
+  // Depends on activePacks() so it re-fetches whenever active packs change.
+  const [allPacks, { refetch: refetchAll }] = createResource(
+    () => (kpExpanded() ? { sessionID: props.sessionID, active: activePacks() } : null),
+    async ({ sessionID }) => {
+      const res = await sdkGet("/session/{sessionID}/knowledge-packs/available", { sessionID })
+      if (res.error) return [] as KPEntry[]
+      return res.data as KPEntry[]
+    },
+  )
+
+  const visiblePacks = () => (kpExpanded() ? (allPacks() ?? []) : (activePacks() ?? []))
+
+  function togglePack(name: string, version: string, enabled: boolean) {
+    const sessionID = props.sessionID
+    // Fire-and-forget the SDK call, then refetch once the server responds.
+    // The refetch is deferred with setTimeout so the DOM update happens
+    // outside opentui's mouse event processing — avoiding the race that
+    // destroys renderables mid-event and corrupts focus state.
+    const req = enabled
+      ? sdkDelete("/session/{sessionID}/knowledge-packs/{name}/{version}", { sessionID, name, version })
+      : sdkPost("/session/{sessionID}/knowledge-packs/{name}/{version}", { sessionID, name, version })
+    req.then(() => setTimeout(() => refetchActive(), 1))
+  }
+
+  const promptRef = usePromptRef()
+
+  // After any sidebar mouse interaction opentui clears currentFocusedRenderable
+  // because sidebar box elements are not focusable renderables. The native
+  // layer may also do post-processing (hover recheck, mouseUp dispatch) after
+  // the JS callback returns, so a synchronous focus() can be overwritten.
+  // Use setTimeout like the dialog system does, and schedule a second check
+  // to catch focus loss from async re-renders triggered by resource refetch.
+  function refocusPrompt() {
+    setTimeout(() => {
+      promptRef.current?.focus()
+    }, 1)
+    setTimeout(() => {
+      if (!promptRef.current?.focused) promptRef.current?.focus()
+    }, 50)
+  }
+
   const directory = useDirectory()
   const kv = useKV()
 
@@ -102,6 +176,13 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
               <text fg={theme.text}>
                 <b>Context</b>
               </text>
+              <text fg={theme.textMuted}>
+                compact{" "}
+                {sync.data.config.compaction?.auto === false
+                  ? "disabled"
+                  : kv.get("compaction_method", sync.data.config.compaction?.method ?? "standard")}
+              </text>
+
               <text fg={theme.textMuted}>{context()?.tokens ?? 0} tokens</text>
               <text fg={theme.textMuted}>{context()?.percentage ?? 0}% used</text>
               <text fg={theme.textMuted}>{cost()} spent</text>
@@ -111,7 +192,10 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
                 <box
                   flexDirection="row"
                   gap={1}
-                  onMouseDown={() => mcpEntries().length > 2 && setExpanded("mcp", !expanded.mcp)}
+                  onMouseDown={() => {
+                    mcpEntries().length > 2 && setExpanded("mcp", !expanded.mcp)
+                    refocusPrompt()
+                  }}
                 >
                   <Show when={mcpEntries().length > 2}>
                     <text fg={theme.text}>{expanded.mcp ? "▼" : "▶"}</text>
@@ -167,11 +251,54 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
                 </Show>
               </box>
             </Show>
+            <box>
+              <box flexDirection="row" gap={1} justifyContent="space-between">
+                <text fg={theme.text}>
+                  <b>Knowledge Packs</b>
+                </text>
+                <text
+                  fg={theme.textMuted}
+                  onMouseDown={() => {
+                    setKpExpanded(!kpExpanded())
+                    if (!kpExpanded()) refetchAll()
+                    refocusPrompt()
+                  }}
+                >
+                  {kpExpanded() ? "−" : "+"}
+                </text>
+              </box>
+
+              <For each={visiblePacks()}>
+                {(kp) => (
+                  <box
+                    flexDirection="row"
+                    gap={1}
+                    onMouseDown={() => {
+                      togglePack(kp.name, kp.version, kp.enabled)
+                      refocusPrompt()
+                    }}
+                  >
+                    <text flexShrink={0} style={{ fg: kp.enabled ? theme.success : theme.textMuted }}>
+                      {kp.enabled ? "•" : "◦"}
+                    </text>
+                    <text fg={kp.enabled ? theme.text : theme.textMuted} wrapMode="word">
+                      {kp.displayName}
+                      <Show when={kp.version}>
+                        <span style={{ fg: theme.textMuted }}> {kp.version}</span>
+                      </Show>
+                    </text>
+                  </box>
+                )}
+              </For>
+            </box>
             <box>
               <box
                 flexDirection="row"
                 gap={1}
-                onMouseDown={() => sync.data.lsp.length > 2 && setExpanded("lsp", !expanded.lsp)}
+                onMouseDown={() => {
+                  sync.data.lsp.length > 2 && setExpanded("lsp", !expanded.lsp)
+                  refocusPrompt()
+                }}
               >
                 <Show when={sync.data.lsp.length > 2}>
                   <text fg={theme.text}>{expanded.lsp ? "▼" : "▶"}</text>
@@ -215,7 +342,10 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
                 <box
                   flexDirection="row"
                   gap={1}
-                  onMouseDown={() => todo().length > 2 && setExpanded("todo", !expanded.todo)}
+                  onMouseDown={() => {
+                    todo().length > 2 && setExpanded("todo", !expanded.todo)
+                    refocusPrompt()
+                  }}
                 >
                   <Show when={todo().length > 2}>
                     <text fg={theme.text}>{expanded.todo ? "▼" : "▶"}</text>
@@ -234,7 +364,10 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
                 <box
                   flexDirection="row"
                   gap={1}
-                  onMouseDown={() => diff().length > 2 && setExpanded("diff", !expanded.diff)}
+                  onMouseDown={() => {
+                    diff().length > 2 && setExpanded("diff", !expanded.diff)
+                    refocusPrompt()
+                  }}
                 >
                   <Show when={diff().length > 2}>
                     <text fg={theme.text}>{expanded.diff ? "▼" : "▶"}</text>
@@ -288,7 +421,13 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
                   <text fg={theme.text}>
                     <b>Getting started</b>
                   </text>
-                  <text fg={theme.textMuted} onMouseDown={() => kv.set("dismissed_getting_started", true)}>
+                  <text
+                    fg={theme.textMuted}
+                    onMouseDown={() => {
+                      kv.set("dismissed_getting_started", true)
+                      refocusPrompt()
+                    }}
+                  >
                     ✕
                   </text>
                 </box>