docs: WebView mode, app ingestion Steps 1+2, session log 2026-05-20b\n\nREADME:\n- Six agents named; mcp/ and webview/ in package layout\n- App ingestion quick-start: ingest <url> and browse <url>\n- DbC paragraph: MCPAgent/WebAgent + autonomy dial\n\nARCHITECTURE.md:\n- Verified-against commit df4372d\n- KindIngest and KindBrowse in request flow diagram\n- DBC table: MCPAgent and WebAgent rows; autonomy dial table\n\ndocs/concepts/app-ingestion.md:\n- Status: Steps 1+2 implemented, Step 3 research-phase\n- Dependency chain: Steps 1+2 SHIPPED with commit hashes\n\ndocs/session-2026-05-20b.md:\n- Block 4 ChatAgent, Step 1 MCP, Step 2 WebView\n- Toolchain resolution (chromedp dropped, Go 1.25.10 confirmed)\n- End state: 12 packages, 6 agents, 5 workspace types, 8 intent kinds

Author: goweft

ARCHITECTURE.md

@@ -1,7 +1,7 @@
 # CAS Architecture
 
 **Last updated:** 2026-05-19
-**Verified against:** commit `6b4ef8d`
+**Verified against:** commit `df4372d`
 
 ---
 
@@ -26,10 +26,12 @@ cmd/cas/main.go          Entry point. Wires store → shell → TUI and starts
 internal/
   intent/     detect.go  Zero-latency regex classifier. Fires before any LLM
                          call. Maps a user message to a Kind and workspace type.
-  agent/      agent.go    Named sub-agents with per-agent contracts. Four agents:
+  agent/      agent.go    Named sub-agents with per-agent contracts. Six agents:
                          GenerationAgent (create), EditAgent (edit), CombineAgent (combine),
-                         ChatAgent (chat). Shell delegates to agents; agents own every LLM call.
-                         Shell has no remaining LLM call sites — it only routes.
+                         ChatAgent (chat), MCPAgent (mcp tool calls), WebAgent (web actions).
+                         Shell delegates to agents; agents own every LLM call.
+              mcp_agent.go  MCPAgent: tool-call planning + execution, autonomy dial.
+              web_agent.go  WebAgent: web action planning (answer/navigate/extract), autonomy dial.
   contract/   contract.go  Design by Contract enforcement. Pre/post/invariant
                          checks on workspace operations. Fail-closed.
   workspace/  workspace.go  Workspace type and lifecycle (create, update, close,
@@ -50,7 +52,11 @@ internal/
                          *.lua. Sandboxed VM; no file I/O, no network.
   conductor/  conductor.go  Behavioral learning. Observes interactions, builds
                          ~/.cas/profile.json, injects context into LLM prompts.
-  mcp/                   MCP integration layer (in progress).
+  mcp/        client.go  MCP client layer. Connect(), discoverTools(), Call(), Close().
+                         SSE transport via mark3labs/mcp-go.
+  webview/    browser.go HTTP fetch + golang.org/x/net/html parser.
+                         NewSession(), Navigate(), Fetch(), FormatPageState().
+                         Extracts title, headings, links, body text; no browser runtime.
 
 ui/           model.go   Bubble Tea TUI model. Renders chat + workspace panels,
                          handles keyboard, streams tokens into workspace view.
@@ -90,6 +96,18 @@ intent.Detect()               ← regex only, no LLM call, no latency
      │                   contract.CheckPostconditions()  ← non-empty, ≤512 KB
      │                   workspace.Create()
      │
+     ├─ KindIngest  →  MCPAgent (bound to workspace)
+     │                   contract.CheckPreconditions()   ← instruction, connection, tools, autonomy
+     │                   llm.Complete() → tool selection
+     │                   contract.CheckPostconditions()  ← tool name exists on server
+     │                   mcp.Connection.Call()  (if autonomy ≠ suggest)
+     │
+     ├─ KindBrowse  →  WebAgent (bound to workspace)
+     │                   contract.CheckPreconditions()   ← instruction, session, page state, autonomy
+     │                   llm.Complete() → action selection (answer/navigate/extract)
+     │                   contract.CheckPostconditions()  ← navigate_url valid if set
+     │                   webview.Session.Fetch()  (if action = navigate)
+     │
      └─ KindChat    →  ChatAgent
                          contract.CheckPreconditions()   ← message non-empty, history ≤ 20 turns
                          llm.Stream()
@@ -134,10 +152,20 @@ Per-agent contract rules:
 | EditAgent         | wsType valid, content non-empty, request non-empty | result non-empty, ≤ 512 KB, ≥ 10% of original        |
 | CombineAgent      | ≥ 2 sources, all sources non-empty                 | result non-empty, ≤ 512 KB                            |
 | ChatAgent         | message non-empty, history ≤ 20 turns              | reply guaranteed (fallback applied before check)      |
+| MCPAgent          | instruction non-empty, connection present, ≥1 tool, autonomy valid | selected tool name exists on server    |
+| WebAgent          | instruction non-empty, session present, page state present, autonomy valid | navigate_url (if set) is absolute |
 
 The 10% truncation guard on EditAgent catches cases where the model returns
 only a fragment of the updated document instead of the full content.
 
+**Autonomy dial** (MCPAgent and WebAgent):
+
+| Value     | Behaviour                                                        |
+|-----------|------------------------------------------------------------------|
+| `suggest` | LLM plans the action; tool/navigation not executed              |
+| `confirm` | Action executed; result surfaced before continuing              |
+| `run`     | Action executed freely within workspace scope                   |
+
 ChatAgent's postcondition is a guarantee rather than a hard check — if the
 model returns an empty reply, the fallback nudge is substituted before the
 postcondition runs, ensuring the contract is always satisfied.

README.md

@@ -85,7 +85,9 @@ contract.CheckPostconditions()  // did the output meet requirements?
 
 Contracts run in Go, external to the model. The model cannot modify, bypass, or reason about them. Any violation fails the operation — fail-closed always. Based on Bertrand Meyer's Design by Contract (1988).
 
-Every LLM call is owned by a named agent (`GenerationAgent`, `EditAgent`, `CombineAgent`, `ChatAgent`). Contracts are frozen before the LLM call and checked again after. The shell delegates to agents and has no remaining LLM call sites — it only routes.
+Every LLM call is owned by a named agent (`GenerationAgent`, `EditAgent`, `CombineAgent`, `ChatAgent`, `MCPAgent`, `WebAgent`). Contracts are frozen before the LLM call and checked again after. The shell delegates to agents and has no remaining LLM call sites — it only routes.
+
+`MCPAgent` and `WebAgent` operate under an **autonomy dial** (`suggest` / `confirm` / `run`) that governs whether actions are planned only, executed with confirmation, or executed freely within their workspace scope. The contract enforces that any tool or URL used exists on the bound server or page — the agent cannot reach outside its workspace.
 
 ### Three workspace types
 
@@ -215,15 +217,18 @@ Full terminal editor via `charmbracelet/bubbles` textarea. All standard cursor m
 ```
 internal/
 ├── intent/      Zero-latency intent detection — regex, no LLM call
-├── agent/       Named sub-agents: GenerationAgent, EditAgent, CombineAgent, ChatAgent
-│                Each owns one category of LLM call with a frozen contract
+├── agent/       Six named sub-agents, each with a frozen contract
+│                GenerationAgent, EditAgent, CombineAgent, ChatAgent,
+│                MCPAgent (tool calls), WebAgent (web actions)
 │                Shell has no remaining LLM call sites — it only routes
 ├── contract/    Design by Contract enforcement, fail-closed
 ├── workspace/   Lifecycle: create, update, undo, close, restore
 ├── shell/       Session manager: ProcessMessage, StreamMessage
 ├── llm/         Ollama, Anthropic, Groq, OpenAI, OpenRouter — streaming/sync, model routing
 ├── runner/      Code execution — sandboxed subprocess, timeout, env isolation
 ├── plugin/      Lua plugin runtime — sandboxed gopher-lua VM
+├── mcp/         MCP client — connect, discover tools, call, close (SSE transport)
+├── webview/     HTTP fetch + HTML parser — title, headings, links, body text
 ├── store/       Store interface, SQLiteStore (WAL), MemoryStore
 └── conductor/   Behavioral learning — observe, profile, user_context
 ui/              Bubble Tea TUI: split panel, tabs, streaming, inline edit
@@ -292,6 +297,28 @@ CAS_MODEL_CODE=anthropic/claude-3-5-haiku ./cas
 ./cas --providers
 ```
 
+### Ingest an MCP server
+
+```bash
+# In chat: connects and opens a workspace with the server's tools listed
+ingest https://mcp.linear.app/sse
+
+# Then ask the agent to use a tool:
+# "list my open issues"  →  MCPAgent reasons, selects tool, calls it
+```
+
+### Browse a web page
+
+```bash
+# In chat: fetches the page and opens a workspace with its content
+browse https://golang.org
+
+# Then ask the agent to work with it:
+# "summarise the main sections"
+# "navigate to https://golang.org/doc/install"
+# "extract all links"
+```
+
 ### Flags
 
 ```

docs/concepts/app-ingestion.md

@@ -1,6 +1,6 @@
 # App Ingestion
 
-**Status:** Concept. Depends on sub-agent decomposition (planned, not yet designed).
+**Status:** Steps 1 and 2 implemented. Step 3 (native app) research-phase.
 
 ---
 
@@ -184,16 +184,16 @@ Prerequisite ──────── sub-agent decomposition with Heddle contra
                       Not yet designed in detail. Load-bearing for what
                       follows — every ingested workspace binds a sub-agent.
 
-Step 1 ────────────── API-mode ingestion
+Step 1 ────────────── API-mode ingestion  ✓ SHIPPED (784e94e)
                       · Workspace surface (operations + state + sub-agent)
                       · Autonomy dial
                       · Scoped memory with intent tags
 
-Step 2 ────────────── WebView-mode ingestion
+Step 2 ────────────── WebView-mode ingestion  ✓ SHIPPED (df4372d)
                       · Embedded browser runtime
                       · Authoritative DOM access
 
-Step 3 ────────────── Native app window adoption
+Step 3 ────────────── Native app window adoption  (research-phase)
                       · Platform-specific (research-heavy)
 ```
 

docs/session-2026-05-20b.md

@@ -0,0 +1,80 @@
+# Session Log — 2026-05-20 (continued)
+
+## What we worked on
+
+### Block 4: ChatAgent
+
+**ChatAgent** (`6b4ef8d`)
+Final agent in the decomposition. Owns all KindChat LLM calls.
+- Preconditions: message non-empty, history ≤ 20 turns
+- Postcondition: reply guaranteed — fallback nudge substituted if model
+  returns empty, so the contract is always satisfied rather than failing
+- `contextSuffix()` helper removed from shell (chat-agent owns it internally)
+- Shell has zero remaining LLM call sites — it only routes
+
+Shell updated: `handleChat`/`streamChat` → `chatAgent.Chat`/`Stream`.
+Tests: +2 contract violation tests (empty message, excessive history).
+Docs: README and ARCHITECTURE updated — all four agents named, shell-only-routes.
+
+### App ingestion Step 1: MCP server as workspace
+
+**MCP client + MCPAgent + KindIngest** (`784e94e`)
+- `internal/mcp/client.go`: Connect(), discoverTools(), Call(), Close()
+  SSE transport via mark3labs/mcp-go v0.54.0
+- `internal/agent/mcp_agent.go`: MCPAgent with three-level autonomy dial
+  (suggest/confirm/run). LLM selects tool + args from server tool summary;
+  JSON response parsed to MCPToolCall; plain-text fallback if no tool selected.
+  Contract: instruction non-empty, connection present, ≥1 tool, autonomy valid;
+  post: selected tool name must exist on the server
+- KindIngest in intent: `ingest <url>`, `connect (to) <url>`,
+  `add (mcp) server/source <url>`
+- Shell: handleIngest → Connect → materialize 'mcp' workspace → bind connection;
+  HandleMCPAction, CloseMCPWorkspace exposed for UI layer
+- DefaultWorkspaceContract accepts 'mcp' type
+- Tests: 5 MCPAgent contract tests, 6+4 ingest intent tests
+
+### App ingestion Step 2: WebView mode
+
+**WebView + WebAgent + KindBrowse** (`df4372d`)
+- `internal/webview/browser.go`: stdlib HTTP + golang.org/x/net/html
+  NewSession(), Navigate(), Fetch(), FormatPageState(), ParseForTest()
+  Parser: title, headings (h1–h3), links (top 30, absolute URLs), body text
+  Script/style excluded; body truncated to 4 KB
+- `internal/agent/web_agent.go`: WebAgent with WebAction types
+  (answer/navigate/extract), same autonomy dial as MCPAgent
+  LLM selects action from page context summary; JSON response or plain-text fallback
+  Contract: instruction, session, page state, autonomy; post: navigate_url valid
+- KindBrowse in intent: browse/open/scrape/fetch/read/summarise/summarize/
+  go to + URL
+- Shell: handleBrowse, HandleWebAction (updates page state on navigate),
+  CloseWebWorkspace
+- DefaultWorkspaceContract accepts 'web' type
+- Tests: 7 webview parser tests, 4 WebAgent contract tests,
+  8+5 browse intent tests
+
+**Toolchain resolution** (also in df4372d)
+  chromedp (Go 1.26 requirement) dropped; stdlib approach used instead.
+  Build verified against Go 1.25.10 at /home/gostev/go-install.
+  go.mod pinned to 1.25.5 (mcp-go requirement). CI unchanged (go-version: '1.25').
+
+## End state
+
+- **HEAD:** `df4372d`
+- **Packages:** 12 (added internal/mcp, internal/webview)
+- **Agents:** GenerationAgent, EditAgent, CombineAgent, ChatAgent,
+              MCPAgent, WebAgent
+- **Workspace types:** document, code, list, mcp, web
+- **Intent kinds:** create, edit, close, run, combine, chat, ingest, browse
+- **Tests:** all passing across all 12 packages
+- **Go toolchain:** 1.25.10 (local), 1.25.5 (go.mod min), 1.25 (CI)
+
+## What's next
+
+Per concept doc dependency chain:
+- Step 3 (native app window adoption) is research-phase — X11/Wayland,
+  platform-specific, no clear timeline
+- Immediate: update concept doc to mark Steps 1 and 2 as implemented
+- Blog: post 04 still queued for dev.to publish
+- Sub-agent coordination: if two ingested workspaces need to act together
+  (e.g. "take this Linear issue, file a GitHub PR"), the orchestration
+  pattern is not yet designed