Fix planner not producing results from Claude CLI

The --json-schema flag does not enforce JSON output when used with
--output-format stream-json, causing the model to return plain text
instead of valid JSON. The Result field in StreamEvent was also typed
as string, which fails to unmarshal when the CLI returns a JSON object.
Added explicit JSON output instructions to the planner prompt and
changed the Result field to json.RawMessage with a StructuredOutput
fallback. Implemented a multi-strategy JSON extraction pipeline that
tries direct parse, brace-depth extraction from result text, and
assistant text as a last resort. The frontend now displays planner
errors instead of silently swallowing them in console.error.

Author: yessGlory17

backend/claude/process.go

@@ -107,8 +107,8 @@ func StartProcess(ctx context.Context, opts ProcessOptions) (*Process, error) {
 
 	// Parse stdout stream events in background
 	go func() {
-		defer close(p.events)
 		defer close(p.done)
+		defer close(p.events)
 
 		log.Printf("[claude] starting stream parser")
 

backend/claude/stream.go

@@ -44,7 +44,7 @@ func ExtractTextContent(event StreamEvent) string {
 			return extractFromContent(event.Message.Content)
 		}
 	case "result":
-		return event.Result
+		return event.ResultText()
 	case "raw":
 		return string(event.Raw)
 	}

backend/claude/types.go

@@ -16,14 +16,34 @@ type StreamEvent struct {
 	Message *Message `json:"message,omitempty"`
 
 	// For result events
-	DurationMS float64 `json:"duration_ms,omitempty"`
-	NumTurns   int     `json:"num_turns,omitempty"`
-	Result     string  `json:"result,omitempty"`
+	DurationMS       float64         `json:"duration_ms,omitempty"`
+	NumTurns         int             `json:"num_turns,omitempty"`
+	Result           json.RawMessage `json:"result,omitempty"`
+	StructuredOutput json.RawMessage `json:"structured_output,omitempty"` // --json-schema validated output
 
 	// Raw JSON for anything we don't parse
 	Raw json.RawMessage `json:"-"`
 }
 
+// ResultText returns the result as a usable string.
+// Priority: structured_output (from --json-schema) > result field.
+// If the value is a JSON string, it unwraps the quotes.
+// If it's a JSON object/array, it returns the raw JSON.
+func (e StreamEvent) ResultText() string {
+	// Prefer structured_output when available (--json-schema validated output)
+	if len(e.StructuredOutput) > 0 {
+		return string(e.StructuredOutput)
+	}
+	if len(e.Result) == 0 {
+		return ""
+	}
+	var s string
+	if err := json.Unmarshal(e.Result, &s); err == nil {
+		return s
+	}
+	return string(e.Result)
+}
+
 // Message represents a Claude message within a stream event.
 type Message struct {
 	Role    string          `json:"role,omitempty"`

backend/services/agent_runner.go

@@ -274,8 +274,8 @@ func (ar *AgentRunner) RunTask(ctx context.Context, task *models.Task, agent *mo
 		// Capture result text via lastText — avoid writing directly to task struct
 		// to prevent data races. Callers apply ResultText from RunResult.LastText.
 		if event.Type == "result" {
-			if event.Result != "" {
-				lastText = event.Result
+			if text := event.ResultText(); text != "" {
+				lastText = text
 			}
 		}
 	}
@@ -438,7 +438,7 @@ func (ar *AgentRunner) emitTaskEvent(taskID string, event claude.StreamEvent) {
 		}
 	case "result":
 		taskEvent.Type = "result"
-		taskEvent.Content = event.Result
+		taskEvent.Content = event.ResultText()
 		taskEvent.Data = map[string]any{
 			"duration_ms": event.DurationMS,
 			"num_turns":   event.NumTurns,

backend/services/planner.go

@@ -6,6 +6,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"log"
 	"strings"
 )
 
@@ -105,7 +106,9 @@ Rules:
 - If a task depends on another, specify the dependency by title
 - Each task prompt should be detailed enough for an AI agent to execute without additional context
 - Keep task count between 2-8 tasks
-%s`, goal, agentInfo, agentRule)
+%s
+IMPORTANT: You MUST respond with ONLY a valid JSON object, no other text. The JSON must follow this exact structure:
+{"summary": "Brief description of the overall plan", "tasks": [{"title": "Short task title", "prompt": "Detailed prompt for the agent", "dependencies": ["titles of dependent tasks"], "agent_id": "ID of assigned agent"}]}`, goal, agentInfo, agentRule)
 
 	proc, err := claude.StartProcess(ctx, claude.ProcessOptions{
 		WorkDir:     projectPath,
@@ -122,10 +125,14 @@ Rules:
 	// Collect all output. With --json-schema, the result event contains validated JSON.
 	var resultJSON string
 	var assistantText strings.Builder
+	eventCount := 0
 	for event := range proc.Events() {
+		eventCount++
+		log.Printf("[planner] event #%d: type=%s subtype=%s resultLen=%d structuredOutputLen=%d", eventCount, event.Type, event.Subtype, len(event.Result), len(event.StructuredOutput))
 		switch event.Type {
 		case "result":
-			resultJSON = event.Result
+			resultJSON = event.ResultText()
+			log.Printf("[planner] captured result (len=%d): %.200s", len(resultJSON), resultJSON)
 		case "assistant":
 			text := claude.ExtractTextContent(event)
 			if text != "" {
@@ -136,16 +143,40 @@ Rules:
 
 	<-proc.Done()
 
-	// Primary path: parse the result event (validated by --json-schema)
+	log.Printf("[planner] stream ended: %d events, resultJSON len=%d, assistantText len=%d", eventCount, len(resultJSON), assistantText.Len())
+
+	// Try multiple strategies to extract the JSON result.
 	raw := resultJSON
-	if raw == "" {
-		// Fallback: try assistant text with brace-depth extraction
-		raw = extractJSON(assistantText.String())
-	}
 
 	var result PlanResult
-	if err := json.Unmarshal([]byte(raw), &result); err != nil {
-		return nil, fmt.Errorf("parse planner response: %w (raw: %s)", err, truncate(raw, 500))
+	parsed := false
+
+	// Strategy 1: Direct parse of result event
+	if raw != "" {
+		if err := json.Unmarshal([]byte(raw), &result); err == nil {
+			parsed = true
+			log.Printf("[planner] parsed result directly (len=%d)", len(raw))
+		} else {
+			log.Printf("[planner] direct parse failed: %v, trying extractJSON on result", err)
+			// Strategy 2: Extract JSON from result text (model may have mixed text + JSON)
+			extracted := extractJSON(raw)
+			if extracted != raw {
+				if err := json.Unmarshal([]byte(extracted), &result); err == nil {
+					parsed = true
+					log.Printf("[planner] parsed result via extractJSON (len=%d)", len(extracted))
+				}
+			}
+		}
+	}
+
+	// Strategy 3: Extract JSON from assistant text
+	if !parsed {
+		raw = extractJSON(assistantText.String())
+		log.Printf("[planner] trying assistantText extractJSON (len=%d): %.200s", len(raw), raw)
+		if err := json.Unmarshal([]byte(raw), &result); err != nil {
+			log.Printf("[planner] all parse strategies failed: %v", err)
+			return nil, fmt.Errorf("parse planner response: %w (raw: %s)", err, truncate(raw, 500))
+		}
 	}
 
 	if len(result.Tasks) == 0 {

backend/services/prompt_improver.go

@@ -97,7 +97,7 @@ Return the improved prompt and explanation.`, metaContext, draft)
 	for event := range proc.Events() {
 		switch event.Type {
 		case "result":
-			resultJSON = event.Result
+			resultJSON = event.ResultText()
 		case "assistant":
 			text := claude.ExtractTextContent(event)
 			if text != "" {

frontend/src/pages/SessionPlanner.tsx

@@ -36,6 +36,7 @@ export function SessionPlanner() {
   const [planning, setPlanning] = useState(false)
   const [proposedTasks, setProposedTasks] = useState<ProposedTask[]>([])
   const [planSummary, setPlanSummary] = useState('')
+  const [planError, setPlanError] = useState('')
 
   const [expandedTask, setExpandedTask] = useState<string | null>(null)
 
@@ -133,12 +134,14 @@ export function SessionPlanner() {
     setPlanning(true)
     setProposedTasks([])
     setPlanSummary('')
+    setPlanError('')
     try {
       const result = await window.go.main.App.PlanTasks(currentSession.project_id, goal.trim())
       setProposedTasks(result.tasks || [])
       setPlanSummary(result.summary || '')
-    } catch (e) {
+    } catch (e: any) {
       console.error('Planning failed:', e)
+      setPlanError(e?.message || String(e) || 'Planning failed')
     } finally {
       setPlanning(false)
     }
@@ -290,6 +293,11 @@ export function SessionPlanner() {
                 rows={3}
                 className="w-full px-3 py-2 bg-white/[0.04] border border-white/[0.08] rounded-lg text-sm text-zinc-100 placeholder:text-zinc-600 input-focus resize-none transition-colors"
               />
+              {planError && (
+                <div className="mt-3 px-3 py-2 bg-red-500/10 border border-red-500/20 rounded-lg">
+                  <p className="text-xs text-red-400">{planError}</p>
+                </div>
+              )}
               <div className="flex gap-2 mt-3">
                 <button
                   onClick={handlePlan}