feat(ai): unify codex live event rendering with history output

Add synthetic claude.ToolUse objects to ai.Event.Raw for codex live streams, enabling the shared lineRenderer to format codex events identically to `captain history` output. This eliminates duplicate rendering logic and ensures consistent session banners, tool rows, and result footers with cost/usage information.

Introduce three helper functions (codexToolUse, codexResultToolUse, codexSessionToolUse) to construct the synthetic ToolUse objects, and add renderCodexEntry to route codex events through the unified rendering path. Include comprehensive test coverage verifying the integration.

Author: moshloop

pkg/ai/provider/codex_cli.go

@@ -13,6 +13,7 @@ import (
 	"time"
 
 	"github.com/flanksource/captain/pkg/ai"
+	"github.com/flanksource/captain/pkg/claude"
 	"github.com/flanksource/commons/logger"
 )
 
@@ -309,7 +310,9 @@ func mapCodexEvent(line, model string) (ai.Event, bool) {
 		if len(msg.Input) > 0 {
 			_ = json.Unmarshal(msg.Input, &input)
 		}
-		return ai.Event{Kind: ai.EventToolUse, Tool: msg.Name, Input: input, Model: model}, true
+		out := ai.Event{Kind: ai.EventToolUse, Tool: msg.Name, Input: input, Model: model}
+		out.Raw = codexToolUse(msg.Name, input, ev.ID, model)
+		return out, true
 	case "task_complete", "result", "completion":
 		out := ai.Event{Kind: ai.EventResult, Tool: "Result", Model: model, Success: msg.Error == "", CostUSD: msg.Cost}
 		if msg.Usage != nil {
@@ -318,6 +321,7 @@ func mapCodexEvent(line, model string) (ai.Event, bool) {
 		if msg.Error != "" {
 			out.Error = msg.Error
 		}
+		out.Raw = codexResultToolUse(out, ev.ID)
 		return out, true
 	case "error", "task_error":
 		errText := firstNonEmpty(msg.Error, msg.Message, ev.Message)
@@ -326,12 +330,16 @@ func mapCodexEvent(line, model string) (ai.Event, bool) {
 		}
 		return ai.Event{Kind: ai.EventError, Error: extractCodexErrorText(errText), Model: model}, true
 	case "session_configured", "session_init":
-		return ai.Event{Kind: ai.EventSystem, Tool: "SessionInit", SessionID: ev.ID, Model: model}, true
+		out := ai.Event{Kind: ai.EventSystem, Tool: "SessionInit", SessionID: ev.ID, Model: model}
+		out.Raw = codexSessionToolUse(ev.ID, model)
+		return out, true
 
 	// --- Newer dotted-type schema ---
 	case "thread.started":
 		sessionID := firstNonEmpty(ev.ThreadID, ev.ID)
-		return ai.Event{Kind: ai.EventSystem, Tool: "SessionInit", SessionID: sessionID, Model: model}, true
+		out := ai.Event{Kind: ai.EventSystem, Tool: "SessionInit", SessionID: sessionID, Model: model}
+		out.Raw = codexSessionToolUse(sessionID, model)
+		return out, true
 	case "turn.started":
 		// Heartbeat — captain does not surface this.
 		return ai.Event{}, false
@@ -353,6 +361,7 @@ func mapCodexEvent(line, model string) (ai.Event, bool) {
 		if ev.Usage != nil {
 			out.Usage = &ai.Usage{InputTokens: ev.Usage.InputTokens, OutputTokens: ev.Usage.OutputTokens}
 		}
+		out.Raw = codexResultToolUse(out, firstNonEmpty(ev.ThreadID, ev.ID))
 		return out, true
 	case "turn.failed":
 		var errText string
@@ -374,6 +383,67 @@ func firstNonEmpty(values ...string) string {
 	return ""
 }
 
+// codexToolUse builds the claude.ToolUse stand-in that mapCodexEvent stashes
+// on ai.Event.Raw so the shared lineRenderer in pkg/cli renders codex live
+// streams identically to `captain history` output. Source is hard-coded to
+// "codex" so sessionKey/sessionHeaderText pick the codex icon and label.
+func codexToolUse(name string, input map[string]any, sessionID, model string) claude.ToolUse {
+	return claude.ToolUse{
+		Tool:      name,
+		Input:     input,
+		SessionID: sessionID,
+		Source:    "codex",
+		Model:     model,
+	}
+}
+
+// codexResultToolUse mirrors the synthetic Result row that
+// pkg/cli/ai.go's renderResultEvent constructs for Claude, preserving cost,
+// usage, and error state so the "🏁 result …" footer renders consistently.
+func codexResultToolUse(ev ai.Event, sessionID string) claude.ToolUse {
+	input := map[string]any{}
+	for k, v := range ev.Input {
+		input[k] = v
+	}
+	if ev.CostUSD > 0 {
+		if _, ok := input["total_cost_usd"]; !ok {
+			input["total_cost_usd"] = ev.CostUSD
+		}
+	}
+	tu := claude.ToolUse{
+		Tool:      "Result",
+		Input:     input,
+		SessionID: sessionID,
+		Source:    "codex",
+		Model:     ev.Model,
+	}
+	if ev.Usage != nil {
+		tu.InputTokens = ev.Usage.InputTokens
+		tu.OutputTokens = ev.Usage.OutputTokens
+	}
+	if !ev.Success {
+		tu.IsError = true
+		if ev.Error != "" {
+			if _, ok := tu.Input["result"]; !ok {
+				tu.Input["result"] = ev.Error
+			}
+		}
+	}
+	return tu
+}
+
+// codexSessionToolUse builds the synthetic SessionInit row used by the
+// shared renderer to emit a session-start banner the first time a sessionKey
+// is seen. The lineRenderer treats SessionInit just like any other tool row.
+func codexSessionToolUse(sessionID, model string) claude.ToolUse {
+	return claude.ToolUse{
+		Tool:      "SessionInit",
+		SessionID: sessionID,
+		Source:    "codex",
+		Model:     model,
+	}
+}
+
 // redactCodexArgs returns a copy of args with the trailing prompt truncated so
 // debug logs stay readable. The prompt is the only positional argument and
 // always sits at the end of the argv built by buildCodexExecArgs.

pkg/cli/ai.go

@@ -269,6 +269,11 @@ func renderEvent(w *os.File, renderer *lineRenderer, ev ai.Event) {
 			return
 		}
 	}
+	if tu, ok := ev.Raw.(claude.ToolUse); ok {
+		if renderCodexEntry(renderer, ev, tu) {
+			return
+		}
+	}
 
 	switch ev.Kind {
 	case ai.EventText:
@@ -346,6 +351,27 @@ func renderClaudeEntry(renderer *lineRenderer, ev ai.Event, entry claude.History
 	return true
 }
 
+// renderCodexEntry mirrors renderClaudeEntry for codex live events, which
+// stash a synthesized claude.ToolUse on ev.Raw rather than a HistoryEntry
+// (codex's stream schema does not match Claude's message-shaped envelope).
+// Routing the codex tool use through ToolUsesToTools keeps the rendering
+// path identical to `captain history` for codex JSONL.
+func renderCodexEntry(renderer *lineRenderer, ev ai.Event, tu claude.ToolUse) bool {
+	switch ev.Kind {
+	case ai.EventToolUse, ai.EventResult, ai.EventSystem:
+	default:
+		return false
+	}
+	tl := claude.ToolUsesToTools([]claude.ToolUse{tu})
+	if len(tl) == 0 {
+		return false
+	}
+	for _, t := range tl {
+		renderer.Render(t, true)
+	}
+	return true
+}
+
 func summariseInput(input map[string]any) string {
 	if len(input) == 0 {
 		return ""

pkg/cli/ai_render_codex_test.go

@@ -0,0 +1,87 @@
+package cli
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/flanksource/captain/pkg/ai"
+	"github.com/flanksource/captain/pkg/claude"
+)
+
+// TestRenderEvent_CodexLiveUsesLineRenderer verifies that codex live events
+// flow through the same shared lineRenderer as `captain history` does for
+// codex JSONL — emitting a session-start banner, a tool row, and a result row
+// with cost/usage. Without unification, renderEvent falls back to the bare
+// "[tool] name" / "[result] ..." printer.
+func TestRenderEvent_CodexLiveUsesLineRenderer(t *testing.T) {
+	var buf bytes.Buffer
+	renderer := newLineRenderer(&buf, 8)
+
+	session := claude.ToolUse{
+		Tool:      "SessionInit",
+		SessionID: "019e0365-dc2a-7ad0-a5a8-78936481a928",
+		Source:    "codex",
+		Model:     "gpt-5",
+	}
+	exec := claude.ToolUse{
+		Tool:      "Bash",
+		Input:     map[string]any{"command": "ls"},
+		SessionID: "019e0365-dc2a-7ad0-a5a8-78936481a928",
+		Source:    "codex",
+		Model:     "gpt-5",
+	}
+	result := claude.ToolUse{
+		Tool:         "Result",
+		Input:        map[string]any{"total_cost_usd": 0.5},
+		SessionID:    "019e0365-dc2a-7ad0-a5a8-78936481a928",
+		Source:       "codex",
+		Model:        "gpt-5",
+		InputTokens:  100,
+		OutputTokens: 50,
+	}
+
+	renderEvent(nil, renderer, ai.Event{
+		Kind:      ai.EventSystem,
+		Tool:      "SessionInit",
+		SessionID: session.SessionID,
+		Model:     session.Model,
+		Raw:       session,
+	})
+	renderEvent(nil, renderer, ai.Event{
+		Kind:  ai.EventToolUse,
+		Tool:  exec.Tool,
+		Input: exec.Input,
+		Model: exec.Model,
+		Raw:   exec,
+	})
+	renderEvent(nil, renderer, ai.Event{
+		Kind:    ai.EventResult,
+		Tool:    "Result",
+		Model:   result.Model,
+		Success: true,
+		CostUSD: 0.5,
+		Usage:   &ai.Usage{InputTokens: 100, OutputTokens: 50},
+		Raw:     result,
+	})
+
+	out := buf.String()
+	for _, want := range []string{
+		"Codex",     // session header capitalises the source name
+		"gpt-5",     // model in the header
+		"019e0365",  // shortened session id
+		"Bash",      // tool row label
+		"$0.5",      // cost
+	} {
+		if !strings.Contains(out, want) {
+			t.Errorf("rendered output missing %q\nfull output:\n%s", want, out)
+		}
+	}
+
+	// Negative: the bare fallback printer must NOT be used when Raw is set.
+	for _, forbidden := range []string{"[tool]", "[result]", "[session]"} {
+		if strings.Contains(out, forbidden) {
+			t.Errorf("output should not contain bare fallback %q\nfull output:\n%s", forbidden, out)
+		}
+	}
+}