feat: app ingestion Step 2 — WebView mode (HTTP fetch + HTML parsing)\n\nWebView mode ingests a URL as a workspace: fetch, parse, materialize,\nbind WebAgent. No embedded browser runtime — stdlib HTTP and\ngolang.org/x/net/html give authoritative DOM access in a TUI context.\n\ninternal/webview/browser.go (new)\n Session: NewSession(), Navigate(), Fetch(), Close()\n parseHTML(): title, headings (h1–h3), links (top 30), body text\n - Script and style tags excluded from text extraction\n - Body text truncated to 4 KB for workspace display\n - Links resolved to absolute URLs against base\n FormatPageState(): markdown workspace content from PageState\n ParseForTest(): exported test helper for parser unit testing\n\ninternal/agent/web_agent.go (new)\n WebAgent owns all KindBrowse LLM calls and web navigation.\n WebAction types: answer | navigate | extract\n Autonomy dial: same suggest/confirm/run as MCPAgent\n planAction: LLM selects action from page context summary; JSON response\n parsed to webPlan; plain-text fallback treated as answer\n Contract:\n Pre: instruction non-empty, session present, page state present,\n autonomy valid\n Post: navigate_url (if set) must be a parseable absolute URL\n\ninternal/intent/detect.go\n KindBrowse kind added\n browsePatterns: browse/open/scrape/fetch/read/summarise/summarize/\n go to + URL\n extractBrowseURL: pulls URL into TitleHint\n\ninternal/contract/contract.go\n DefaultWorkspaceContract now accepts 'web' workspace type\n\ninternal/shell/shell.go\n Shell holds webAgent, webSessions, webPages\n handleBrowse: NewSession → Navigate → materialize 'web' workspace\n HandleWebAction: dispatch instruction to WebAgent; updates page state\n on navigation\n CloseWebWorkspace: cleanup on workspace close\n KindBrowse routed in ProcessMessage and StreamMessage\n\ngo.mod: golang.org/x/net/html added (was already indirect via other deps)\n go directive pinned to 1.25.5; chromedp (Go 1.26 requirement) not used.\n Build verified against Go 1.25.10 at /home/gostev/go-install.\n\nTests:\n internal/webview: 7 tests — title, headings, links, script exclusion,\n body text, FormatPageState output, NewSession invalid URL\n internal/agent: +4 WebAgent contract tests (empty instruction, nil\n session, nil page state, invalid autonomy)\n internal/intent: +TestBrowseDetection (8 patterns),\n +TestBrowseDoesNotMatchNormal (5 non-URL cases)

Author: goweft

go.mod

@@ -9,6 +9,7 @@ require (
 	github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834
 	github.com/mark3labs/mcp-go v0.54.0
 	github.com/yuin/gopher-lua v1.1.2
+	golang.org/x/net v0.54.0
 	modernc.org/sqlite v1.48.1
 )
 
@@ -49,10 +50,9 @@ require (
 	github.com/yosida95/uritemplate/v3 v3.0.2 // indirect
 	github.com/yuin/goldmark v1.7.13 // indirect
 	github.com/yuin/goldmark-emoji v1.0.6 // indirect
-	golang.org/x/net v0.38.0 // indirect
-	golang.org/x/sys v0.42.0 // indirect
-	golang.org/x/term v0.36.0 // indirect
-	golang.org/x/text v0.30.0 // indirect
+	golang.org/x/sys v0.44.0 // indirect
+	golang.org/x/term v0.43.0 // indirect
+	golang.org/x/text v0.37.0 // indirect
 	modernc.org/libc v1.70.0 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect

go.sum

@@ -119,22 +119,22 @@ github.com/yuin/gopher-lua v1.1.2 h1:yF/FjE3hD65tBbt0VXLE13HWS9h34fdzJmrWRXwobGA
 github.com/yuin/gopher-lua v1.1.2/go.mod h1:7aRmXIWl37SqRf0koeyylBEzJ+aPt8A+mmkQ4f1ntR8=
 golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 h1:mgKeJMpvi0yx/sU5GsxQ7p6s2wtOnGAHZWCHUM4KGzY=
 golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546/go.mod h1:j/pmGrbnkbPtQfxEe5D0VQhZC6qKbfKifgD0oM7sR70=
-golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=
-golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=
-golang.org/x/net v0.38.0 h1:vRMAPTMaeGqVhG5QyLJHqNDwecKTomGeqbnfZyKlBI8=
-golang.org/x/net v0.38.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
-golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
-golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/mod v0.35.0 h1:Ww1D637e6Pg+Zb2KrWfHQUnH2dQRLBQyAtpr/haaJeM=
+golang.org/x/mod v0.35.0/go.mod h1:+GwiRhIInF8wPm+4AoT6L0FA1QWAad3OMdTRx4tFYlU=
+golang.org/x/net v0.54.0 h1:2zJIZAxAHV/OHCDTCOHAYehQzLfSXuf/5SoL/Dv6w/w=
+golang.org/x/net v0.54.0/go.mod h1:Sj4oj8jK6XmHpBZU/zWHw3BV3abl4Kvi+Ut7cQcY+cQ=
+golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
-golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/term v0.36.0 h1:zMPR+aF8gfksFprF/Nc/rd1wRS1EI6nDBGyWAvDzx2Q=
-golang.org/x/term v0.36.0/go.mod h1:Qu394IJq6V6dCBRgwqshf3mPF85AqzYEzofzRdZkWss=
-golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k=
-golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM=
-golang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k=
-golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=
+golang.org/x/sys v0.44.0 h1:ildZl3J4uzeKP07r2F++Op7E9B29JRUy+a27EibtBTQ=
+golang.org/x/sys v0.44.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/term v0.43.0 h1:S4RLU2sB31O/NCl+zFN9Aru9A/Cq2aqKpTZJ6B+DwT4=
+golang.org/x/term v0.43.0/go.mod h1:lrhlHNdQJHO+1qVYiHfFKVuVioJIheAc3fBSMFYEIsk=
+golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc=
+golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38=
+golang.org/x/tools v0.44.0 h1:UP4ajHPIcuMjT1GqzDWRlalUEoY+uzoZKnhOjbIPD2c=
+golang.org/x/tools v0.44.0/go.mod h1:KA0AfVErSdxRZIsOVipbv3rQhVXTnlU6UhKxHd1seDI=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 modernc.org/cc/v4 v4.27.1 h1:9W30zRlYrefrDV2JE2O8VDtJ1yPGownxciz5rrbQZis=

internal/agent/agent_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/goweft/cas/internal/agent"
 	mcpclient "github.com/goweft/cas/internal/mcp"
+	"github.com/goweft/cas/internal/webview"
 	"github.com/goweft/cas/internal/llm"
 )
 
@@ -287,3 +288,75 @@ func contains(s, sub string) bool {
 			return false
 		}())
 }
+
+// ── WebAgent ──────────────────────────────────────────────────────
+
+func TestWebAgentContractEmptyInstruction(t *testing.T) {
+	a := agent.NewWebAgent()
+	sess, _ := webview.NewSession(nil, "https://example.com")
+	page := &webview.PageState{URL: "https://example.com", Title: "Test"}
+	_, err := a.Act(context.Background(), agent.WebRequest{
+		Instruction: "  ",
+		Session:     sess,
+		PageState:   page,
+		Autonomy:    agent.AutonomySuggest,
+	})
+	if err == nil {
+		t.Fatal("expected contract violation for empty instruction, got nil")
+	}
+	if !strings.Contains(err.Error(), "instruction_not_empty") {
+		t.Errorf("expected instruction_not_empty violation, got: %v", err)
+	}
+}
+
+func TestWebAgentContractNilSession(t *testing.T) {
+	a := agent.NewWebAgent()
+	page := &webview.PageState{URL: "https://example.com"}
+	_, err := a.Act(context.Background(), agent.WebRequest{
+		Instruction: "summarise this page",
+		Session:     nil,
+		PageState:   page,
+		Autonomy:    agent.AutonomySuggest,
+	})
+	if err == nil {
+		t.Fatal("expected contract violation for nil session, got nil")
+	}
+	if !strings.Contains(err.Error(), "session_present") {
+		t.Errorf("expected session_present violation, got: %v", err)
+	}
+}
+
+func TestWebAgentContractNilPageState(t *testing.T) {
+	a := agent.NewWebAgent()
+	sess, _ := webview.NewSession(nil, "https://example.com")
+	_, err := a.Act(context.Background(), agent.WebRequest{
+		Instruction: "summarise this page",
+		Session:     sess,
+		PageState:   nil,
+		Autonomy:    agent.AutonomySuggest,
+	})
+	if err == nil {
+		t.Fatal("expected contract violation for nil page state, got nil")
+	}
+	if !strings.Contains(err.Error(), "page_state_present") {
+		t.Errorf("expected page_state_present violation, got: %v", err)
+	}
+}
+
+func TestWebAgentContractInvalidAutonomy(t *testing.T) {
+	a := agent.NewWebAgent()
+	sess, _ := webview.NewSession(nil, "https://example.com")
+	page := &webview.PageState{URL: "https://example.com"}
+	_, err := a.Act(context.Background(), agent.WebRequest{
+		Instruction: "summarise",
+		Session:     sess,
+		PageState:   page,
+		Autonomy:    agent.Autonomy("turbo"),
+	})
+	if err == nil {
+		t.Fatal("expected contract violation for invalid autonomy, got nil")
+	}
+	if !strings.Contains(err.Error(), "autonomy_valid") {
+		t.Errorf("expected autonomy_valid violation, got: %v", err)
+	}
+}

internal/agent/web_agent.go

@@ -0,0 +1,250 @@
+// web_agent.go — WebAgent: owns all web workspace LLM interactions.
+//
+// The WebAgent reasons about what to do with a web page — extract data,
+// summarise, navigate to a linked page, answer questions — and acts
+// according to the autonomy dial. Like MCPAgent, it never leaves its
+// workspace scope and its contract enforces that navigation stays within
+// the session's origin domain (or an explicitly approved URL).
+package agent
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/goweft/cas/internal/contract"
+	"github.com/goweft/cas/internal/llm"
+	"github.com/goweft/cas/internal/webview"
+)
+
+// WebAction names what the WebAgent decided to do.
+type WebAction string
+
+const (
+	WebActionAnswer   WebAction = "answer"   // answer from current page content
+	WebActionNavigate WebAction = "navigate" // fetch a new URL
+	WebActionExtract  WebAction = "extract"  // extract specific data from the page
+)
+
+// WebRequest is the input to WebAgent.
+type WebRequest struct {
+	Instruction string
+	Session     *webview.Session
+	PageState   *webview.PageState // current page snapshot
+	Autonomy    Autonomy
+	UserContext string
+	Temperature float64
+}
+
+// WebResult is the output from WebAgent.
+type WebResult struct {
+	Action      WebAction
+	Answer      string // populated for WebActionAnswer and WebActionExtract
+	NavigateURL string // populated for WebActionNavigate
+	NewPage     *webview.PageState // populated after navigation
+}
+
+// WebAgent handles web workspace interactions.
+// It owns all KindBrowse LLM calls and web navigation.
+type WebAgent struct{}
+
+// NewWebAgent returns a WebAgent.
+func NewWebAgent() *WebAgent { return &WebAgent{} }
+
+// Act reasons about the instruction against the current page state,
+// then acts according to the autonomy dial.
+func (a *WebAgent) Act(ctx context.Context, req WebRequest) (*WebResult, error) {
+	if err := a.contract(req, "").CheckPreconditions(); err != nil {
+		return nil, err
+	}
+
+	plan, err := a.planAction(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	// In suggest mode, return the plan without acting.
+	if req.Autonomy == AutonomySuggest {
+		result := &WebResult{Action: plan.action, Answer: plan.answer, NavigateURL: plan.navigateURL}
+		if err := a.contract(req, plan.navigateURL).CheckPostconditions(); err != nil {
+			return nil, err
+		}
+		return result, nil
+	}
+
+	// confirm and run: execute the action.
+	switch plan.action {
+	case WebActionNavigate:
+		newPage, err := req.Session.Fetch(ctx, plan.navigateURL)
+		if err != nil {
+			return nil, fmt.Errorf("web-agent: navigate: %w", err)
+		}
+		result := &WebResult{
+			Action:      WebActionNavigate,
+			NavigateURL: plan.navigateURL,
+			NewPage:     newPage,
+		}
+		if err := a.contract(req, plan.navigateURL).CheckPostconditions(); err != nil {
+			return nil, err
+		}
+		return result, nil
+
+	default: // answer or extract — no network call
+		result := &WebResult{Action: plan.action, Answer: plan.answer}
+		if err := a.contract(req, "").CheckPostconditions(); err != nil {
+			return nil, err
+		}
+		return result, nil
+	}
+}
+
+type webPlan struct {
+	action      WebAction
+	answer      string
+	navigateURL string
+}
+
+// planAction asks the LLM what to do with the current page.
+func (a *WebAgent) planAction(ctx context.Context, req WebRequest) (*webPlan, error) {
+	sys := a.systemPrompt(req)
+	pageContext := formatPageContext(req.PageState)
+
+	msgs := []llm.Message{
+		{Role: "system", Content: sys},
+		{Role: "user", Content: pageContext + "\n\nInstruction: " + req.Instruction},
+	}
+
+	raw, err := llm.Complete(ctx, msgs, llm.ModelFor("chat"), req.Temperature)
+	if err != nil {
+		return nil, fmt.Errorf("web-agent: plan: %w", err)
+	}
+
+	return parseWebPlanResponse(raw), nil
+}
+
+// systemPrompt builds the system prompt for web action planning.
+func (a *WebAgent) systemPrompt(req WebRequest) string {
+	var sb strings.Builder
+	sb.WriteString("You are an assistant operating inside CAS (Conversational Agent Shell).\n")
+	sb.WriteString("You are working with a web page. You can do three things:\n\n")
+	sb.WriteString("1. ANSWER — answer a question from the page content directly.\n")
+	sb.WriteString("2. NAVIGATE — go to a different URL (must be a real link from the page).\n")
+	sb.WriteString("3. EXTRACT — pull out specific structured data from the page.\n\n")
+	sb.WriteString("Respond with ONLY a JSON object:\n")
+	sb.WriteString(`{"action": "answer"|"navigate"|"extract", "answer": "<text>", "navigate_url": "<url>"}`)
+	sb.WriteString("\n\nFor 'answer' and 'extract': populate 'answer'. Leave 'navigate_url' empty.")
+	sb.WriteString("\nFor 'navigate': populate 'navigate_url' with a URL from the page links. Leave 'answer' empty.")
+	sb.WriteString("\n\nScope rule: navigate_url must be a real URL visible in the page content. Never invent URLs.")
+	if req.UserContext != "" {
+		sb.WriteString("\n\nUser context: " + req.UserContext)
+	}
+	return sb.String()
+}
+
+// parseWebPlanResponse parses a JSON action plan from the LLM.
+// Falls back to a plain-text answer if the response is not JSON.
+func parseWebPlanResponse(raw string) *webPlan {
+	raw = strings.TrimSpace(raw)
+	if strings.HasPrefix(raw, "```") {
+		lines := strings.Split(raw, "\n")
+		if len(lines) > 2 {
+			raw = strings.Join(lines[1:len(lines)-1], "\n")
+		}
+	}
+
+	var v struct {
+		Action      string `json:"action"`
+		Answer      string `json:"answer"`
+		NavigateURL string `json:"navigate_url"`
+	}
+	if err := json.Unmarshal([]byte(raw), &v); err != nil {
+		// Plain text — treat as answer
+		return &webPlan{action: WebActionAnswer, answer: strings.TrimSpace(raw)}
+	}
+
+	switch WebAction(v.Action) {
+	case WebActionNavigate:
+		return &webPlan{action: WebActionNavigate, navigateURL: v.NavigateURL}
+	case WebActionExtract:
+		return &webPlan{action: WebActionExtract, answer: v.Answer}
+	default:
+		return &webPlan{action: WebActionAnswer, answer: v.Answer}
+	}
+}
+
+// formatPageContext produces a compact page summary for the LLM prompt.
+func formatPageContext(ps *webview.PageState) string {
+	if ps == nil {
+		return "(no page loaded)"
+	}
+	var sb strings.Builder
+	sb.WriteString("Current page: " + ps.URL + "\n")
+	if ps.Title != "" {
+		sb.WriteString("Title: " + ps.Title + "\n")
+	}
+	if len(ps.Headings) > 0 {
+		sb.WriteString("Headings: " + strings.Join(ps.Headings, " | ") + "\n")
+	}
+	if len(ps.Links) > 0 {
+		sb.WriteString("Links:\n")
+		for _, l := range ps.Links {
+			sb.WriteString("  - " + l.Text + ": " + l.Href + "\n")
+		}
+	}
+	// Truncate text to ~1 KB for prompt
+	text := ps.Text
+	if len(text) > 1024 {
+		text = text[:1024] + "…"
+	}
+	if text != "" {
+		sb.WriteString("Content excerpt:\n" + text + "\n")
+	}
+	return sb.String()
+}
+
+// contract builds and freezes the WebAgent contract.
+func (a *WebAgent) contract(req WebRequest, navigateURL string) *contract.Contract {
+	c := contract.New("web-agent")
+	c.Preconditions = []contract.Rule{
+		{
+			Name:        "instruction_not_empty",
+			Description: "instruction must not be empty",
+			Check:       func() bool { return strings.TrimSpace(req.Instruction) != "" },
+		},
+		{
+			Name:        "session_present",
+			Description: "a web session must be provided",
+			Check:       func() bool { return req.Session != nil },
+		},
+		{
+			Name:        "page_state_present",
+			Description: "a page state must be provided",
+			Check:       func() bool { return req.PageState != nil },
+		},
+		{
+			Name:        "autonomy_valid",
+			Description: "autonomy must be suggest, confirm, or run",
+			Check: func() bool {
+				return req.Autonomy == AutonomySuggest ||
+					req.Autonomy == AutonomyConfirm ||
+					req.Autonomy == AutonomyRun
+			},
+		},
+	}
+	c.Postconditions = []contract.Rule{
+		{
+			Name:        "navigate_url_valid",
+			Description: "navigate_url must be a parseable absolute URL if set",
+			Check: func() bool {
+				if navigateURL == "" {
+					return true
+				}
+				u, err := url.Parse(navigateURL)
+				return err == nil && u.IsAbs()
+			},
+		},
+	}
+	return c.Freeze()
+}