@swarmclawai/swarmclaw 1.5.62 → 1.5.64

package/README.md

@@ -399,6 +399,31 @@ Operational docs: https://swarmclaw.ai/docs/observability
 
 ## Releases
 
+### v1.5.64 Highlights
+
+Two themes this release. First, **context-window management reaches the chat UI**: a live token-usage meter in every chat header, a one-click LLM-backed compaction that keeps the session alive without nuking history, and a redesigned clear flow with a 30-second undo that restores both transcripts and CLI resume IDs. Second, **MCP token spend is now controllable**: per-server `alwaysExpose` policy, per-agent eager-tool overrides, an in-session `mcp_tool_search` promoter, a long-lived connection pool, a token-cost endpoint per server, and a built-in browser for the public SwarmDock MCP registry.
+
+- **Context meter in the chat header.** New `ContextMeterBadge` (`src/components/chat/context-meter-badge.tsx`) renders a live chip showing `N% · Mk` next to the chat title, driven by `GET /api/chats/:id/context-status`. Color thresholds at 70% (amber) and 90% (red). Clicking the chip opens a popover with the full breakdown (used / remaining / messages) plus Compact and Clear buttons. The button row explicitly states: *"Long-term memory, skills, and facts are preserved. Clear only affects this chat transcript."* — so users stop fearing Clear.
+- **User-invokable `/compact` via the popover.** New `POST /api/chats/:id/compact` runs `summarizeAndCompact` with the session's own provider/model via `buildChatModel` as the summarizer. The existing hierarchical-summary pipeline in `context-manager.ts` does the work: tool failures, file ops, and adaptive chunking are all preserved. Accepts `keepLastN` in the body (2-200, default 10). Returns `status: 'no_action' | 'compacted'` plus counts. The popover gates the button below 3 messages so users don't waste LLM calls on trivially short transcripts.
+- **Clear with 30-second undo.** `POST /api/chats/:id/clear` now returns `{ cleared, undoToken, expiresAt }`, and a new `POST /api/chats/:id/clear/undo` restores the snapshot. The undo snapshot (messages + every CLI session ID including `claudeSessionId`, `codexThreadId`, `opencodeSessionId`, `opencodeWebSessionId`, `geminiSessionId`, `copilotSessionId`, `droidSessionId`, `cursorSessionId`, `qwenSessionId`, `acpSessionId`, and `delegateResumeIds`) lives in an HMR-safe in-memory store (`src/lib/server/chats/clear-undo-snapshots.ts`) with a 30-second TTL, 200-entry cap, session-scoped lookups, and single-use tokens. The chat UI wires this to a sonner toast with an Undo action; restoring fires a "Chat restored." confirmation toast.
+- **`alwaysExpose` policy for MCP servers** (`McpServerConfig.alwaysExpose: boolean | string[]`, default `true` for back-compat). Set `false` on a chatty server (e.g. a Playwright MCP with 40 tools that cost thousands of tokens per turn) and the agent binds nothing up front — it can still discover and promote specific tools via the new `mcp_tool_search` meta-tool. Set an allowlist `['query_resources', 'fetch_url']` to eagerly bind a curated subset.
+- **Per-agent `mcpEagerTools` override** (`Agent.mcpEagerTools?: string[]`) lets you force-expose specific tool names for a specific agent regardless of the server's `alwaysExpose`. Precedence: per-agent allowlist > server `alwaysExpose` > session promotions.
+- **`mcp_tool_search` meta-tool** (`src/lib/server/mcp-gateway-runtime.ts`). When a server's tools are lazy, the agent gets a single `mcp_tool_search({ query, limit? })` tool that searches the process-wide discovery cache (bare name substring + description keywords) and promotes matches for the current session. The next turn binds the promoted names for real. `SessionToolPromoter` state is keyed by session ID and HMR-safe. Behavior mirrors `@swarmclawai/mcp-gateway`'s router so users who split MCP fan-out across SwarmClaw and the gateway get consistent semantics.
+- **Long-lived MCP connection pool** (`src/lib/server/mcp-connection-pool.ts`). A single client/transport per server lives for the process lifetime instead of reconnecting every turn. Config-fingerprint tracking rotates stale entries automatically; the `/test` endpoint evicts explicitly so a config change takes effect immediately. Saves ~100-500ms × (servers × turns) per chat. HMR-safe via `hmrSingleton` so dev reloads don't leak child processes.
+- **Token-cost discovery endpoint** (`GET /api/mcp-servers/:id/tools-info`). Connects, lists tools, and reports per-tool schema tokens plus aggregates — using the same `chars / 3.5` formula as `@swarmclawai/mcp-gateway` so numbers line up side by side. Surfaces inside `mcp-server-list.tsx` so you can see which server is the costliest before an agent even runs.
+- **SwarmDock MCP Registry browser** (`src/components/mcp-servers/registry-browser.tsx`). Opens from the New MCP Server sheet and browses the public registry at `https://swarmdock-api.onrender.com/api/v1/mcp/servers`. Selecting a server populates the form with its recommended install command — one-click discovery without leaving SwarmClaw. A new `MCP Gateway (local)` preset is also bundled so users can bootstrap `@swarmclawai/mcp-gateway` in one tap.
+- **4 new CLI commands.** `swarmclaw chats context-status <id>`, `swarmclaw chats compact <id>`, `swarmclaw chats clear-undo <id>`, and the existing `chats clear` now returns the undo token so CLI scripts can build their own clear+undo workflows.
+- **Back-compat normalization.** Existing MCP servers load with `alwaysExpose: true` (historical behavior — every tool bound every turn) via `storage-normalization.ts`. No user action required to upgrade.
+- **Full regression coverage.** New tests: `clear-undo-snapshots.test.ts` (5 cases — TTL, single-use, session isolation, CLI-id preservation, expiry sweep), `clear-route.test.ts` (clear → undo → double-undo 404 → missing-session 404 round-trip), `compact-route.test.ts` (no-action path + 404), `context-status-route.test.ts`, plus `mcp-connection-pool.test.ts` and `mcp-gateway-runtime.test.ts`. `test:runtime` runs 100 tests across 13 suites.
+
+### v1.5.63 Highlights
+
+Chatroom fix from @borislavnnikolov: CLI-backed agents (codex-cli, copilot-cli, gemini-cli, and the rest of the `NON_LANGGRAPH_PROVIDER_IDS` set) now work correctly as chatroom members instead of falling through a LangGraph path they cannot run. With the execution path fixed, the worker-only membership blocks are lifted too, so any non-trashed agent can be added to a room.
+
+- **Direct provider runtime for CLI chatroom turns.** `src/app/api/chatrooms/[id]/chat/route.ts` now branches on `NON_LANGGRAPH_PROVIDER_IDS` and calls `provider.handler.streamChat()` directly for CLI-backed agents while keeping the LangGraph `streamAgentChat` path for everything else. Streaming, tool events, and persisted messages all flow through unchanged.
+- **Full member selection.** The create, update, members, session-tool, and UI layers (`src/app/api/chatrooms/route.ts`, `src/app/api/chatrooms/[id]/route.ts`, `src/app/api/chatrooms/[id]/members/route.ts`, `src/lib/server/session-tools/chatroom.ts`, `src/components/chatrooms/chatroom-sheet.tsx`) no longer reject or hide worker-only agents. Any non-trashed agent is eligible.
+- **Regression test.** `src/app/api/chatrooms/[id]/chat/route.test.ts` proves a `codex-cli`-backed chatroom turn bypasses `streamAgentChat`, streams a response through the provider handler, and persists one assistant reply.
+
 ### v1.5.62 Highlights
 
 Hardens parallel sub-agent dispatch with a concurrency cap, a quorum join policy, and a cycle check — so a fan-out can't accidentally saturate providers, melt a mission budget, or wedge the runtime on a delegation loop.
@@ -432,16 +457,6 @@ Viral-loop release. Adds public share links for missions, skills, and sessions,
 - **Share-link-based skill install.** `POST /api/skills/import` already accepts an http(s) URL; pointing it at `https://<your-host>/api/s/<token>/raw` now installs a shared skill from another SwarmClaw instance without auth handshakes. Pairs naturally with existing `swarmclaw skills import` CLI.
 - **Share-link repository tests.** `share-link-repository.test.ts` covers mint / list / revoke / lookup-by-token round-trip plus expiry handling against a temporary data dir.
 
-### v1.5.58 Highlights
-
-This release broadens the built-in evaluation harness so SwarmClaw runs can be benchmarked against named suites, adds two targeted starter kits, exposes live per-session cost data, tightens auto-skill drafting, and ships a zero-setup demo mission template.
-
-- **Benchmark-style eval suites.** New `SWEBENCH_LITE_SCENARIOS` and `GAIA_L1_SCENARIOS` in `src/lib/server/eval/scenarios-swebench.ts` and `scenarios-gaia.ts` — curated parallels (not the upstream datasets) sized for a single-agent harness run. The shared `EvalScenario` type now carries an optional `suite: 'core' | 'swe-bench-lite' | 'gaia-l1' | 'tool-use' | 'code-action'` tag. `POST /api/eval/suite` accepts `{ suite: "swe-bench-lite" }` to scope a run. New `GET /api/eval/suites` lists every suite with scenario count, max score, and categories. CLI commands: `swarmclaw eval suites`, and `swarmclaw eval suite` still takes a JSON body now including `suite`. Useful for advertising verifiable numbers against a named benchmark instead of a bespoke scoring rubric.
-- **Two additional starter kits.** `inbox_triage` (single Triager agent over email + memory + documents) and `data_analyst` (single Analyst agent over shell + files + web + documents) join the existing seven kits in `src/lib/setup-defaults.ts`. Both are surfaced on the intent-driven setup path alongside Personal Assistant, Research Copilot, Builder Studio, and Delegate Team.
-- **Live per-session usage API.** New `GET /api/usage/live?sessionId=...` returns a lightweight snapshot — records, tokens in/out, estimated cost, firstAt/lastAt, wallclockMs, turns — so frontends can surface a live cost meter without pulling the full aggregated `/api/usage` payload. Without a `sessionId` the route returns the ten most recently active sessions. Registered in the CLI as `swarmclaw usage live`.
-- **Auto-skill drafting is stricter and rate-limited.** `shouldAutoDraftSkillSuggestion` in `chat-turn-finalization.ts` now requires at least 3 tool events in the completed turn (was 1), and a new per-agent daily cap limits automatic drafts to 3 per day per agent to prevent suggestion-inbox spam. Both thresholds are named constants (`AUTO_DRAFT_MIN_TOOL_EVENTS`, `AUTO_DRAFT_DAILY_LIMIT`). Agents with `autoDraftSkillSuggestions = false` are unaffected (auto-drafting remains opt-in per agent).
-- **Hello World demo mission template.** New `hello-world-demo` entry in `BUILT_IN_MISSION_TEMPLATES` — a bounded, zero-setup mission that reads three files in the working directory and writes a one-paragraph markdown summary to `hello-world-report.md`. Budgets (USD 0.25, 20k tokens, 30 turns, 15 min) are small enough to run on a local Ollama model without cost. Intended as the first thing a new user watches an agent complete end to end.
-
 Older releases: https://swarmclaw.ai/docs/release-notes
 
 - GitHub releases: https://github.com/swarmclawai/swarmclaw/releases

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.5.62",
+  "version": "1.5.64",
   "description": "Build and run autonomous AI agents with OpenClaw, Hermes, multiple model providers, orchestration, delegation, memory, skills, schedules, and chat connectors.",
   "main": "electron-dist/main.js",
   "license": "MIT",
@@ -80,7 +80,7 @@
     "test:cli": "node --test src/cli/*.test.js bin/*.test.js scripts/postinstall.test.mjs scripts/run-next-build.test.mjs scripts/run-next-typegen.test.mjs",
     "test:setup": "tsx --test src/app/api/setup/check-provider/route.test.ts src/lib/server/provider-model-discovery.test.ts src/components/auth/setup-wizard/utils.test.ts src/components/auth/setup-wizard/types.test.ts src/hooks/setup-done-detection.test.ts src/lib/setup-defaults.test.ts src/lib/server/storage-auth.test.ts src/lib/server/storage-auth-docker.test.ts",
     "test:openclaw": "tsx --test src/lib/openclaw/openclaw-agent-id.test.ts src/lib/openclaw/openclaw-endpoint.test.ts src/lib/server/agents/agent-runtime-config.test.ts src/lib/server/build-llm.test.ts src/lib/server/connectors/connector-routing.test.ts src/lib/server/connectors/openclaw.test.ts src/lib/server/connectors/swarmdock.test.ts src/lib/server/gateway/protocol.test.ts src/lib/server/llm-response-cache.test.ts src/lib/server/mcp-conformance.test.ts src/lib/server/openclaw/agent-resolver.test.ts src/lib/server/openclaw/deploy.test.ts src/lib/server/openclaw/skills-normalize.test.ts src/lib/server/session-tools/openclaw-nodes.test.ts src/lib/server/session-tools/swarmdock.test.ts src/lib/server/tasks/task-quality-gate.test.ts src/lib/server/tasks/task-validation.test.ts src/lib/server/tool-capability-policy.test.ts src/lib/providers/openclaw-exports.test.ts src/app/api/openclaw/dashboard-url/route.test.ts",
-    "test:runtime": "tsx --test src/lib/server/knowledge-sources.test.ts src/lib/server/chat-execution/chat-execution-grounding.test.ts src/lib/server/chat-execution/chat-turn-preparation.test.ts src/lib/server/chat-execution/iteration-timers.test.ts src/lib/server/chat-execution/post-stream-finalization.test.ts src/lib/server/connectors/email.test.ts src/lib/server/protocols/protocol-service.test.ts src/lib/server/runtime/run-ledger.test.ts src/lib/server/observability/otel-config.test.ts src/lib/server/safe-parse-body.test.ts src/app/api/approvals/route.test.ts src/app/api/agents/agents-route.test.ts src/app/api/tasks/tasks-route.test.ts src/app/api/chats/chat-route.test.ts src/app/api/connectors/connector-doctor-route.test.ts src/app/api/healthz/route.test.ts src/app/api/logs/route.test.ts src/app/api/tts/route.test.ts",
+    "test:runtime": "tsx --test src/lib/server/mcp-gateway-runtime.test.ts src/lib/server/mcp-connection-pool.test.ts src/lib/server/knowledge-sources.test.ts src/lib/server/chat-execution/chat-execution-grounding.test.ts src/lib/server/chat-execution/chat-turn-preparation.test.ts src/lib/server/chat-execution/iteration-timers.test.ts src/lib/server/chat-execution/post-stream-finalization.test.ts src/lib/server/chats/clear-undo-snapshots.test.ts src/lib/server/connectors/email.test.ts src/lib/server/protocols/protocol-service.test.ts src/lib/server/runtime/run-ledger.test.ts src/lib/server/observability/otel-config.test.ts src/lib/server/safe-parse-body.test.ts src/app/api/approvals/route.test.ts src/app/api/agents/agents-route.test.ts src/app/api/tasks/tasks-route.test.ts src/app/api/chats/chat-route.test.ts src/app/api/chats/clear-route.test.ts src/app/api/chats/compact-route.test.ts src/app/api/chats/context-status-route.test.ts src/app/api/connectors/connector-doctor-route.test.ts src/app/api/healthz/route.test.ts src/app/api/logs/route.test.ts src/app/api/tts/route.test.ts",
     "test:builder": "tsx --test src/features/protocols/builder/utils/nodes-to-template.test.ts src/features/protocols/builder/utils/template-to-nodes.test.ts src/features/protocols/builder/validators/dag-validator.test.ts",
     "test:e2e": "tsx .workbench/browser-e2e/run.ts",
     "test:mcp:conformance": "node --import tsx ./scripts/mcp-conformance-check.ts",

package/src/app/api/chatrooms/[id]/chat/route.test.ts

@@ -297,3 +297,114 @@ test('chatroom route forwards tool activity and records one reply per participat
   assert.deepEqual(output.assistantCounts, { alpha: 1, beta: 1 })
   assert.deepEqual([...new Set(output.agentOrder)].sort(), ['alpha', 'beta'])
 })
+
+test('chatroom route uses direct provider runtime for CLI providers', () => {
+  const output = runWithTempDataDir<{
+    errors: string[]
+    streamedText: string
+    assistantTexts: string[]
+  }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const providersMod = await import('@/lib/providers')
+    const routeMod = await import('./src/app/api/chatrooms/[id]/chat/route')
+    const streamMod = await import('@/lib/server/chat-execution/stream-agent-chat')
+    const storage = storageMod.default || storageMod
+    const providers = providersMod.default || providersMod
+    const route = routeMod.default || routeMod
+    const stream = streamMod.default || streamMod
+
+    const originalHandler = providers.PROVIDERS['codex-cli'].handler
+
+    const now = Date.now()
+    storage.saveAgents({
+      alpha: {
+        id: 'alpha',
+        name: 'Alpha',
+        provider: 'codex-cli',
+        model: 'gpt-5.3-codex',
+        extensions: [],
+        createdAt: now,
+        updatedAt: now,
+      },
+    })
+    storage.saveChatrooms({
+      room_1: {
+        id: 'room_1',
+        name: 'CLI Room',
+        agentIds: ['alpha'],
+        messages: [],
+        createdAt: now,
+        updatedAt: now,
+        chatMode: 'sequential',
+        autoAddress: true,
+      },
+    })
+
+    async function readSse(response) {
+      const reader = response.body.getReader()
+      const decoder = new TextDecoder()
+      let buffer = ''
+      const events = []
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        buffer += decoder.decode(value, { stream: true })
+        let idx = buffer.indexOf('\\n\\n')
+        while (idx !== -1) {
+          const chunk = buffer.slice(0, idx)
+          buffer = buffer.slice(idx + 2)
+          const line = chunk
+            .split('\\n')
+            .map((entry) => entry.trim())
+            .find((entry) => entry.startsWith('data: '))
+          if (line) {
+            events.push(JSON.parse(line.slice(6)))
+          }
+          idx = buffer.indexOf('\\n\\n')
+        }
+      }
+      return events
+    }
+
+    stream.setStreamAgentChatForTest(async () => {
+      throw new Error('streamAgentChat should not be called for codex-cli chatroom turns')
+    })
+    providers.PROVIDERS['codex-cli'].handler = {
+      streamChat: async (opts) => {
+        const reply = 'Codex CLI answered from direct provider runtime.'
+        opts.write('data: ' + JSON.stringify({ t: 'd', text: reply }) + '\\n')
+        return reply
+      },
+    }
+
+    try {
+      const response = await route.POST(
+        new Request('http://local/api/chatrooms/room_1/chat', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ senderId: 'user', text: 'Say hello to the room.' }),
+        }),
+        { params: Promise.resolve({ id: 'room_1' }) },
+      )
+
+      const events = await readSse(response)
+      const chatroom = storage.loadChatrooms().room_1
+      const assistantTexts = chatroom.messages
+        .filter((entry) => entry.role === 'assistant')
+        .map((entry) => entry.text)
+
+      console.log(JSON.stringify({
+        errors: events.filter((entry) => entry.t === 'err').map((entry) => entry.text),
+        streamedText: events.filter((entry) => entry.t === 'd').map((entry) => entry.text).join(''),
+        assistantTexts,
+      }))
+    } finally {
+      providers.PROVIDERS['codex-cli'].handler = originalHandler
+      stream.setStreamAgentChatForTest(null)
+    }
+  `, { prefix: 'swarmclaw-chatroom-route-cli-provider-' })
+
+  assert.equal(output.errors.some((text) => /streamAgentChat should not be called/i.test(text)), false)
+  assert.equal(output.streamedText.includes('Codex CLI answered from direct provider runtime.'), true)
+  assert.equal(output.assistantTexts.some((text) => text.includes('Codex CLI answered from direct provider runtime.')), true)
+})

package/src/app/api/chatrooms/[id]/chat/route.ts

@@ -6,6 +6,7 @@ import { notFound } from '@/lib/server/collection-helpers'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 import { streamAgentChat } from '@/lib/server/chat-execution/stream-agent-chat'
 import { getProvider } from '@/lib/providers'
+import { NON_LANGGRAPH_PROVIDER_IDS } from '@/lib/provider-sets'
 import {
   resolveApiKey,
   parseMentions,
@@ -231,37 +232,55 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
 
             let fullText = ''
             let agentError = ''
-            const result = await streamAgentChat({
-              session: syntheticSession,
-              message: messageForAgent,
-              imagePath,
-              attachedFiles,
-              apiKey,
-              systemPrompt: fullSystemPrompt,
-              write: (raw: string) => {
-                const lines = raw.split('\n').filter(Boolean)
-                for (const line of lines) {
-                  if (!line.startsWith('data: ')) continue
-                  try {
-                    const parsed = JSON.parse(line.slice(6).trim())
-                    if (parsed.t === 'd' && parsed.text) {
-                      fullText += parsed.text
-                      writeEvent({ t: 'd', text: parsed.text, agentId: agent.id, agentName: agent.name })
-                    } else if (parsed.t === 'tool_call' || parsed.t === 'tool_result') {
-                      writeEvent({ ...parsed, agentId: agent.id, agentName: agent.name })
-                    } else if (parsed.t === 'err' && parsed.text) {
-                      agentError = parsed.text
-                      writeEvent({ t: 'err', text: parsed.text, agentId: agent.id, agentName: agent.name })
-                    }
-                  } catch {
-                    // skip malformed lines
+            const forwardProviderEvents = (raw: string) => {
+              const lines = raw.split('\n').filter(Boolean)
+              for (const line of lines) {
+                if (!line.startsWith('data: ')) continue
+                try {
+                  const parsed = JSON.parse(line.slice(6).trim())
+                  if (parsed.t === 'd' && parsed.text) {
+                    fullText += parsed.text
+                    writeEvent({ t: 'd', text: parsed.text, agentId: agent.id, agentName: agent.name })
+                  } else if (parsed.t === 'tool_call' || parsed.t === 'tool_result') {
+                    writeEvent({ ...parsed, agentId: agent.id, agentName: agent.name })
+                  } else if (parsed.t === 'err' && parsed.text) {
+                    agentError = parsed.text
+                    writeEvent({ t: 'err', text: parsed.text, agentId: agent.id, agentName: agent.name })
                   }
+                } catch {
+                  // skip malformed lines
                 }
-              },
-              history,
-            })
+              }
+            }
 
-            const rawResponseText = result.finalResponse || result.fullText || fullText
+            let rawResponseText = ''
+            if (NON_LANGGRAPH_PROVIDER_IDS.has(syntheticSession.provider)) {
+              const provider = getProvider(syntheticSession.provider)
+              if (!provider) throw new Error(`Unknown provider: ${syntheticSession.provider}`)
+              rawResponseText = await provider.handler.streamChat({
+                session: syntheticSession,
+                message: messageForAgent,
+                imagePath,
+                apiKey,
+                systemPrompt: fullSystemPrompt,
+                write: forwardProviderEvents,
+                active: new Map<string, unknown>(),
+                loadHistory: () => history,
+              })
+              if (!rawResponseText) rawResponseText = fullText
+            } else {
+              const result = await streamAgentChat({
+                session: syntheticSession,
+                message: messageForAgent,
+                imagePath,
+                attachedFiles,
+                apiKey,
+                systemPrompt: fullSystemPrompt,
+                write: forwardProviderEvents,
+                history,
+              })
+              rawResponseText = result.finalResponse || result.fullText || fullText
+            }
             const responseText = stripAgentReactionTokens(stripHiddenControlTokens(rawResponseText))
 
             // Don't persist empty or error-only messages — they pollute chat history

package/src/app/api/chatrooms/[id]/members/route.ts

@@ -4,7 +4,6 @@ import { notify } from '@/lib/server/ws-hub'
 import { notFound } from '@/lib/server/collection-helpers'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 import { genId } from '@/lib/id'
-import { isWorkerOnlyAgent, buildWorkerOnlyAgentMessage } from '@/lib/server/agents/agent-availability'
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
@@ -18,13 +17,6 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   if (!agentId) return NextResponse.json({ error: 'agentId is required' }, { status: 400 })
 
   const agents = loadAgents()
-  if (isWorkerOnlyAgent(agents[agentId])) {
-    return NextResponse.json(
-      { error: buildWorkerOnlyAgentMessage(agents[agentId], 'join chatrooms') },
-      { status: 400 },
-    )
-  }
-
   if (!chatroom.agentIds.includes(agentId)) {
     chatroom.agentIds.push(agentId)
 

package/src/app/api/chatrooms/[id]/route.ts

@@ -4,7 +4,6 @@ import { notify } from '@/lib/server/ws-hub'
 import { notFound } from '@/lib/server/collection-helpers'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 import { genId } from '@/lib/id'
-import { isWorkerOnlyAgent } from '@/lib/server/agents/agent-availability'
 import {
   ensureChatroomRoutingGuidance,
   synthesizeRoutingGuidanceFromRules,
@@ -78,16 +77,6 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
         { status: 400 },
       )
     }
-    const cliAgentNames = agentIds
-      .filter((agentId) => isWorkerOnlyAgent(agents[agentId]))
-      .map((agentId) => agents[agentId]?.name || agentId)
-    if (cliAgentNames.length > 0) {
-      return NextResponse.json(
-        { error: `CLI-based agents cannot join chatrooms: ${cliAgentNames.join(', ')}. They can only be used for direct chats and delegation.` },
-        { status: 400 },
-      )
-    }
-
     const oldIds = new Set(chatroom.agentIds)
     const newIds = new Set(agentIds)
     const added = agentIds.filter((aid: string) => !oldIds.has(aid))

package/src/app/api/chatrooms/route.ts

@@ -6,7 +6,6 @@ import { ChatroomCreateSchema, formatZodError } from '@/lib/validation/schemas'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 import { z } from 'zod'
 import type { Chatroom, ChatroomMessage } from '@/types'
-import { isWorkerOnlyAgent } from '@/lib/server/agents/agent-availability'
 import {
   ensureChatroomRoutingGuidance,
   synthesizeRoutingGuidanceFromRules,
@@ -61,15 +60,6 @@ export async function POST(req: Request) {
       { status: 400 },
     )
   }
-  const cliAgentNames = requestedAgentIds
-    .filter((agentId) => isWorkerOnlyAgent(knownAgents[agentId]))
-    .map((agentId) => knownAgents[agentId]?.name || agentId)
-  if (cliAgentNames.length > 0) {
-    return NextResponse.json(
-      { error: `CLI-based agents cannot join chatrooms: ${cliAgentNames.join(', ')}. They can only be used for direct chats and delegation.` },
-      { status: 400 },
-    )
-  }
   const agentIds: string[] = requestedAgentIds
   const chatMode = body.chatMode === 'parallel' ? 'parallel' : 'sequential'
   const autoAddress = Boolean(body.autoAddress)

package/src/app/api/chats/[id]/clear/route.ts

@@ -1,9 +1,13 @@
 import { NextResponse } from 'next/server'
-import { clearChatMessages } from '@/lib/server/chats/chat-session-service'
+import { clearChatMessagesWithUndo } from '@/lib/server/chats/chat-session-service'
 import { notFound } from '@/lib/server/collection-helpers'
 
 export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  if (!clearChatMessages(id)) return notFound()
-  return new NextResponse('OK')
+  const result = clearChatMessagesWithUndo(id)
+  if (!result.ok) {
+    if (result.status === 404) return notFound()
+    return NextResponse.json(result.payload, { status: result.status })
+  }
+  return NextResponse.json(result.payload)
 }

package/src/app/api/chats/[id]/clear/undo/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { restoreChatFromUndoToken } from '@/lib/server/chats/chat-session-service'
+import { badRequest, notFound } from '@/lib/server/collection-helpers'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
+
+const BodySchema = z.object({
+  undoToken: z.string().min(1),
+})
+
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const parsed = await safeParseBody(req, BodySchema)
+  if (parsed.error) return parsed.error
+  const token = parsed.data.undoToken.trim()
+  if (!token) return badRequest('undoToken is required')
+  const result = restoreChatFromUndoToken(id, token)
+  if (!result.ok) {
+    if (result.status === 404) return notFound(result.payload.error)
+    return NextResponse.json(result.payload, { status: result.status })
+  }
+  return NextResponse.json(result.payload)
+}

package/src/app/api/chats/[id]/compact/route.ts

@@ -0,0 +1,72 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { HumanMessage } from '@langchain/core/messages'
+import { getSession } from '@/lib/server/sessions/session-repository'
+import { getMessages, replaceAllMessages } from '@/lib/server/messages/message-repository'
+import { summarizeAndCompact, type LLMSummarizer } from '@/lib/server/context-manager'
+import { buildChatModel } from '@/lib/server/build-llm'
+import { notFound } from '@/lib/server/collection-helpers'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
+import { errorMessage } from '@/lib/shared-utils'
+
+const BodySchema = z.object({
+  keepLastN: z.number().int().min(2).max(200).optional(),
+}).partial()
+
+const DEFAULT_KEEP_LAST_N = 10
+
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const session = getSession(id)
+  if (!session) return notFound()
+
+  const parsed = await safeParseBody(req, BodySchema)
+  if (parsed.error) return parsed.error
+  const keepLastN = Math.max(2, Math.min(parsed.data.keepLastN ?? DEFAULT_KEEP_LAST_N, 200))
+
+  const messages = getMessages(id)
+  if (messages.length <= keepLastN) {
+    return NextResponse.json({
+      status: 'no_action',
+      messageCount: messages.length,
+      keepLastN,
+    })
+  }
+
+  const generateSummary: LLMSummarizer = async (prompt) => {
+    const llm = buildChatModel({
+      provider: session.provider,
+      model: session.model,
+      apiKey: null,
+      credentialId: session.credentialId ?? null,
+      apiEndpoint: session.apiEndpoint ?? null,
+    })
+    const res = await llm.invoke([new HumanMessage(prompt)])
+    return typeof res.content === 'string' ? res.content : ''
+  }
+
+  try {
+    const result = await summarizeAndCompact({
+      messages,
+      keepLastN,
+      agentId: session.agentId ?? null,
+      sessionId: id,
+      provider: session.provider as string,
+      model: session.model as string,
+      generateSummary,
+    })
+    replaceAllMessages(id, result.messages)
+    return NextResponse.json({
+      status: 'compacted',
+      prunedCount: result.prunedCount,
+      memoriesStored: result.memoriesStored,
+      summaryAdded: result.summaryAdded,
+      messageCount: result.messages.length,
+    })
+  } catch (err: unknown) {
+    return NextResponse.json(
+      { error: `Compaction failed: ${errorMessage(err)}` },
+      { status: 500 },
+    )
+  }
+}

package/src/app/api/chats/[id]/context-status/route.ts

@@ -0,0 +1,21 @@
+import { NextResponse } from 'next/server'
+import { getSession } from '@/lib/server/sessions/session-repository'
+import { getMessages } from '@/lib/server/messages/message-repository'
+import { getContextStatus } from '@/lib/server/context-manager'
+import { notFound } from '@/lib/server/collection-helpers'
+
+const SYSTEM_PROMPT_TOKEN_ESTIMATE = 2000
+
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const session = getSession(id)
+  if (!session) return notFound()
+  const messages = getMessages(id)
+  const status = getContextStatus(
+    messages,
+    SYSTEM_PROMPT_TOKEN_ESTIMATE,
+    session.provider as string,
+    session.model as string,
+  )
+  return NextResponse.json(status)
+}

package/src/app/api/chats/clear-route.test.ts

@@ -0,0 +1,121 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+test('chat clear + undo round-trip restores messages and CLI session IDs', () => {
+  const output = runWithTempDataDir<{
+    clearStatus: number
+    clearPayload: { cleared: number; undoToken: string }
+    postClearCount: number
+    postClearClaudeSessionId: string | null
+    postClearOpencodeWebSessionId: string | null
+    undoStatus: number
+    undoPayload: { restored: number }
+    postUndoCount: number
+    postUndoClaudeSessionId: string | null
+    postUndoOpencodeWebSessionId: string | null
+    undoTwiceStatus: number
+    undoTwicePayload: { error?: string }
+    missingSessionStatus: number
+  }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const repoMod = await import('@/lib/server/messages/message-repository')
+    const clearRouteMod = await import('./src/app/api/chats/[id]/clear/route')
+    const undoRouteMod = await import('./src/app/api/chats/[id]/clear/undo/route')
+    const storage = storageMod.default || storageMod
+    const repo = repoMod.default || repoMod
+    const clearRoute = clearRouteMod.default || clearRouteMod
+    const undoRoute = undoRouteMod.default || undoRouteMod
+
+    const now = Date.now()
+    storage.saveSessions({
+      sess_clear_1: {
+        id: 'sess_clear_1',
+        name: 'Clear test',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'tester',
+        provider: 'openai',
+        model: 'gpt-5',
+        claudeSessionId: 'cs_preserved_abc',
+        codexThreadId: null,
+        opencodeWebSessionId: 'owb_preserved_xyz',
+        messages: [],
+        createdAt: now,
+        lastActiveAt: now,
+      },
+    })
+
+    repo.appendMessage('sess_clear_1', { role: 'user', text: 'first', time: now })
+    repo.appendMessage('sess_clear_1', { role: 'assistant', text: 'reply', time: now + 1 })
+    repo.appendMessage('sess_clear_1', { role: 'user', text: 'second', time: now + 2 })
+
+    const clearResponse = await clearRoute.POST(
+      new Request('http://local/api/chats/sess_clear_1/clear', { method: 'POST' }),
+      { params: Promise.resolve({ id: 'sess_clear_1' }) },
+    )
+    const clearPayload = await clearResponse.json()
+
+    const postClearCount = repo.getMessages('sess_clear_1').length
+    const postClearSession = storage.loadSession('sess_clear_1')
+
+    const undoResponse = await undoRoute.POST(
+      new Request('http://local/api/chats/sess_clear_1/clear/undo', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ undoToken: clearPayload.undoToken }),
+      }),
+      { params: Promise.resolve({ id: 'sess_clear_1' }) },
+    )
+    const undoPayload = await undoResponse.json()
+
+    const postUndoCount = repo.getMessages('sess_clear_1').length
+    const postUndoSession = storage.loadSession('sess_clear_1')
+
+    const undoTwiceResponse = await undoRoute.POST(
+      new Request('http://local/api/chats/sess_clear_1/clear/undo', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ undoToken: clearPayload.undoToken }),
+      }),
+      { params: Promise.resolve({ id: 'sess_clear_1' }) },
+    )
+    const undoTwicePayload = await undoTwiceResponse.json()
+
+    const missingResponse = await clearRoute.POST(
+      new Request('http://local/api/chats/not_a_real_session/clear', { method: 'POST' }),
+      { params: Promise.resolve({ id: 'not_a_real_session' }) },
+    )
+
+    console.log(JSON.stringify({
+      clearStatus: clearResponse.status,
+      clearPayload: { cleared: clearPayload.cleared, undoToken: clearPayload.undoToken },
+      postClearCount,
+      postClearClaudeSessionId: postClearSession?.claudeSessionId ?? null,
+      postClearOpencodeWebSessionId: postClearSession?.opencodeWebSessionId ?? null,
+      undoStatus: undoResponse.status,
+      undoPayload,
+      postUndoCount,
+      postUndoClaudeSessionId: postUndoSession?.claudeSessionId ?? null,
+      postUndoOpencodeWebSessionId: postUndoSession?.opencodeWebSessionId ?? null,
+      undoTwiceStatus: undoTwiceResponse.status,
+      undoTwicePayload,
+      missingSessionStatus: missingResponse.status,
+    }))
+  `, { prefix: 'swarmclaw-clear-undo-route-' })
+
+  assert.equal(output.clearStatus, 200)
+  assert.equal(output.clearPayload.cleared, 3)
+  assert.match(output.clearPayload.undoToken, /^undo_/)
+  assert.equal(output.postClearCount, 0)
+  assert.equal(output.postClearClaudeSessionId, null, 'CLI session should be nulled after clear')
+  assert.equal(output.postClearOpencodeWebSessionId, null, 'opencode-web session should be nulled after clear')
+  assert.equal(output.undoStatus, 200)
+  assert.equal(output.undoPayload.restored, 3)
+  assert.equal(output.postUndoCount, 3)
+  assert.equal(output.postUndoClaudeSessionId, 'cs_preserved_abc', 'CLI session ID should be restored by undo')
+  assert.equal(output.postUndoOpencodeWebSessionId, 'owb_preserved_xyz', 'opencode-web session ID should be restored by undo')
+  assert.equal(output.undoTwiceStatus, 404, 'undo token should be single-use')
+  assert.ok(output.undoTwicePayload.error)
+  assert.equal(output.missingSessionStatus, 404)
+})