[codex] add ao hooks activity command

backend/internal/adapters/agent/activitydispatch/dispatch.go

@@ -0,0 +1,32 @@
+// Package activitydispatch is the single source of truth mapping the agent
+// token in `ao hooks <agent> <event>` onto the function that interprets that
+// agent's hook callbacks as an AO activity state.
+package activitydispatch
+
+import (
+	"github.com/aoagents/agent-orchestrator/backend/internal/adapters/agent/claudecode"
+	"github.com/aoagents/agent-orchestrator/backend/internal/adapters/agent/codex"
+	"github.com/aoagents/agent-orchestrator/backend/internal/adapters/agent/opencode"
+	"github.com/aoagents/agent-orchestrator/backend/internal/domain"
+)
+
+// DeriveFunc maps a native agent hook event and its raw stdin payload onto an AO
+// activity state. ok=false means the event carries no activity signal.
+type DeriveFunc func(event string, payload []byte) (domain.ActivityState, bool)
+
+// Derivers maps the agent token in `ao hooks <agent> <event>` to its deriver.
+var Derivers = map[string]DeriveFunc{
+	"claude-code": claudecode.DeriveActivityState,
+	"codex":       codex.DeriveActivityState,
+	"opencode":    opencode.DeriveActivityState,
+}
+
+// Derive looks up the deriver for an agent token and applies it. ok=false when
+// the token has no registered deriver or the event carries no activity signal.
+func Derive(agent, event string, payload []byte) (domain.ActivityState, bool) {
+	derive, found := Derivers[agent]
+	if !found {
+		return "", false
+	}
+	return derive(event, payload)
+}

backend/internal/adapters/agent/claudecode/activity.go

@@ -0,0 +1,51 @@
+package claudecode
+
+import (
+	"encoding/json"
+
+	"github.com/aoagents/agent-orchestrator/backend/internal/domain"
+)
+
+// DeriveActivityState maps a Claude Code hook event and its native stdin payload
+// onto an AO activity state. The bool is false when the event carries no
+// activity signal.
+func DeriveActivityState(event string, payload []byte) (domain.ActivityState, bool) {
+	switch event {
+	case "user-prompt-submit":
+		return domain.ActivityActive, true
+	case "stop":
+		return domain.ActivityIdle, true
+	case "notification":
+		return notificationState(payload)
+	case "session-end":
+		return sessionEndState(payload)
+	default:
+		return "", false
+	}
+}
+
+func notificationState(payload []byte) (domain.ActivityState, bool) {
+	var p struct {
+		NotificationType string `json:"notification_type"`
+	}
+	_ = json.Unmarshal(payload, &p)
+	switch p.NotificationType {
+	case "idle_prompt", "permission_prompt":
+		return domain.ActivityWaitingInput, true
+	default:
+		return "", false
+	}
+}
+
+func sessionEndState(payload []byte) (domain.ActivityState, bool) {
+	var p struct {
+		Reason string `json:"reason"`
+	}
+	_ = json.Unmarshal(payload, &p)
+	switch p.Reason {
+	case "clear", "resume":
+		return "", false
+	default:
+		return domain.ActivityExited, true
+	}
+}

backend/internal/adapters/agent/claudecode/activity_test.go

@@ -0,0 +1,40 @@
+package claudecode
+
+import (
+	"testing"
+
+	"github.com/aoagents/agent-orchestrator/backend/internal/domain"
+)
+
+func TestDeriveActivityState(t *testing.T) {
+	tests := []struct {
+		name    string
+		event   string
+		payload string
+		want    domain.ActivityState
+		wantOK  bool
+	}{
+		{"user prompt -> active", "user-prompt-submit", `{}`, domain.ActivityActive, true},
+		{"stop -> idle", "stop", `{}`, domain.ActivityIdle, true},
+		{"notification idle_prompt -> waiting_input", "notification", `{"notification_type":"idle_prompt"}`, domain.ActivityWaitingInput, true},
+		{"notification permission_prompt -> waiting_input", "notification", `{"notification_type":"permission_prompt"}`, domain.ActivityWaitingInput, true},
+		{"notification auth_success -> no signal", "notification", `{"notification_type":"auth_success"}`, "", false},
+		{"notification malformed payload -> no signal", "notification", `not json`, "", false},
+		{"session-end logout -> exited", "session-end", `{"reason":"logout"}`, domain.ActivityExited, true},
+		{"session-end prompt_input_exit -> exited", "session-end", `{"reason":"prompt_input_exit"}`, domain.ActivityExited, true},
+		{"session-end absent reason -> exited", "session-end", `{}`, domain.ActivityExited, true},
+		{"session-end clear -> no signal", "session-end", `{"reason":"clear"}`, "", false},
+		{"session-end resume -> no signal", "session-end", `{"reason":"resume"}`, "", false},
+		{"session-start -> no signal", "session-start", `{}`, "", false},
+		{"unknown event -> no signal", "frobnicate", `{}`, "", false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, ok := DeriveActivityState(tt.event, []byte(tt.payload))
+			if got != tt.want || ok != tt.wantOK {
+				t.Fatalf("DeriveActivityState(%q, %q) = (%q, %v), want (%q, %v)",
+					tt.event, tt.payload, got, ok, tt.want, tt.wantOK)
+			}
+		})
+	}
+}

backend/internal/adapters/agent/claudecode/claudecode_test.go

@@ -214,6 +214,14 @@ func TestGetAgentHooksInstallsClaudeHooks(t *testing.T) {
 	if m := matcherForCommand(config.Hooks["UserPromptSubmit"], "ao hooks claude-code user-prompt-submit"); m != nil {
 		t.Fatalf("UserPromptSubmit matcher = %v, want none", m)
 	}
+	// Notification and SessionEnd install with no matcher; the handler filters
+	// on the payload.
+	if m := matcherForCommand(config.Hooks["Notification"], "ao hooks claude-code notification"); m != nil {
+		t.Fatalf("Notification matcher = %v, want none", m)
+	}
+	if m := matcherForCommand(config.Hooks["SessionEnd"], "ao hooks claude-code session-end"); m != nil {
+		t.Fatalf("SessionEnd matcher = %v, want none", m)
+	}
 }
 
 func TestUninstallHooksRemovesClaudeHooks(t *testing.T) {

backend/internal/adapters/agent/claudecode/hooks.go

@@ -51,20 +51,27 @@ type claudeHookSpec struct {
 var claudeStartupMatcher = "startup"
 
 // claudeManagedHooks is the source of truth for the hooks AO installs:
-// SessionStart (under the "startup" matcher), UserPromptSubmit, and Stop. Each
-// reports normalized session metadata back into AO's store.
+// SessionStart (under the "startup" matcher), UserPromptSubmit, Stop,
+// Notification, and SessionEnd. They report normalized session metadata and
+// activity-state signals back into AO's store (see DeriveActivityState).
+// Notification and SessionEnd carry no matcher: each installs once and fires
+// for every sub-type, and the handler filters on the payload's
+// notification_type / reason field.
 var claudeManagedHooks = []claudeHookSpec{
 	{Event: "SessionStart", Matcher: &claudeStartupMatcher, Command: claudeHookCommandPrefix + "session-start"},
 	{Event: "UserPromptSubmit", Command: claudeHookCommandPrefix + "user-prompt-submit"},
 	{Event: "Stop", Command: claudeHookCommandPrefix + "stop"},
+	{Event: "Notification", Command: claudeHookCommandPrefix + "notification"},
+	{Event: "SessionEnd", Command: claudeHookCommandPrefix + "session-end"},
 }
 
 // GetAgentHooks installs AO's Claude Code hooks into the worktree-local
 // .claude/settings.local.json file (the per-session local settings, not the
 // shared .claude/settings.json). The hooks (SessionStart, UserPromptSubmit,
-// Stop) report normalized session metadata back into AO's store. Existing
-// hooks and unrelated settings are preserved, and duplicate AO commands
-// are not appended, so the install is idempotent.
+// Stop, Notification, SessionEnd) report normalized session metadata and
+// activity-state signals back into AO's store. Existing hooks and unrelated
+// settings are preserved, and duplicate AO commands are not appended, so
+// the install is idempotent.
 func (p *Plugin) GetAgentHooks(ctx context.Context, cfg ports.WorkspaceHookConfig) error {
 	if err := ctx.Err(); err != nil {
 		return err

backend/internal/adapters/agent/codex/activity.go

@@ -0,0 +1,18 @@
+package codex
+
+import "github.com/aoagents/agent-orchestrator/backend/internal/domain"
+
+// DeriveActivityState maps a Codex hook event onto an AO activity state. The
+// bool is false when the event carries no activity signal.
+func DeriveActivityState(event string, _ []byte) (domain.ActivityState, bool) {
+	switch event {
+	case "user-prompt-submit":
+		return domain.ActivityActive, true
+	case "permission-request":
+		return domain.ActivityWaitingInput, true
+	case "stop":
+		return domain.ActivityIdle, true
+	default:
+		return "", false
+	}
+}

backend/internal/adapters/agent/codex/activity_test.go

@@ -0,0 +1,31 @@
+package codex
+
+import (
+	"testing"
+
+	"github.com/aoagents/agent-orchestrator/backend/internal/domain"
+)
+
+func TestDeriveActivityState(t *testing.T) {
+	tests := []struct {
+		name   string
+		event  string
+		want   domain.ActivityState
+		wantOK bool
+	}{
+		{"user prompt -> active", "user-prompt-submit", domain.ActivityActive, true},
+		{"permission request -> waiting input", "permission-request", domain.ActivityWaitingInput, true},
+		{"stop -> idle", "stop", domain.ActivityIdle, true},
+		{"session start -> no signal", "session-start", "", false},
+		{"unknown event -> no signal", "frobnicate", "", false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, ok := DeriveActivityState(tt.event, []byte(`{}`))
+			if got != tt.want || ok != tt.wantOK {
+				t.Fatalf("DeriveActivityState(%q) = (%q, %v), want (%q, %v)",
+					tt.event, got, ok, tt.want, tt.wantOK)
+			}
+		})
+	}
+}

backend/internal/adapters/agent/codex/codex.go

@@ -61,8 +61,9 @@ func (p *Plugin) GetConfigSpec(ctx context.Context) (ports.ConfigSpec, error) {
 }
 
 // GetLaunchCommand builds the argv to start a new Codex session, applying the
-// no-update-check and approval flags, optional system-prompt instructions, and
-// the initial prompt (passed after `--` so a leading "-" is not read as a flag).
+// no-update-check, hook-trust bypass, and approval flags, optional
+// system-prompt instructions, and the initial prompt (passed after `--` so a
+// leading "-" is not read as a flag).
 func (p *Plugin) GetLaunchCommand(ctx context.Context, cfg ports.LaunchConfig) (cmd []string, err error) {
 	binary, err := p.codexBinary(ctx)
 	if err != nil {
@@ -71,6 +72,7 @@ func (p *Plugin) GetLaunchCommand(ctx context.Context, cfg ports.LaunchConfig) (
 
 	cmd = []string{binary}
 	appendNoUpdateCheckFlag(&cmd)
+	appendHookTrustBypassFlag(&cmd)
 	appendApprovalFlags(&cmd, cfg.Permissions)
 
 	if cfg.SystemPromptFile != "" {
@@ -116,6 +118,7 @@ func (p *Plugin) GetRestoreCommand(ctx context.Context, cfg ports.RestoreConfig)
 	cmd = make([]string, 0, 8)
 	cmd = append(cmd, binary, "resume")
 	appendNoUpdateCheckFlag(&cmd)
+	appendHookTrustBypassFlag(&cmd)
 	appendApprovalFlags(&cmd, cfg.Permissions)
 	cmd = append(cmd, agentSessionID)
 	return cmd, true, nil
@@ -227,6 +230,14 @@ func appendNoUpdateCheckFlag(cmd *[]string) {
 	*cmd = append(*cmd, "-c", "check_for_update_on_startup=false")
 }
 
+func appendHookTrustBypassFlag(cmd *[]string) {
+	// AO installs deterministic workspace-local Codex hooks immediately before
+	// launch/restore. Without this flag, a fresh per-session worktree can skip
+	// those hooks until an interactive /hooks trust review happens, leaving AO
+	// without activity signals.
+	*cmd = append(*cmd, "--dangerously-bypass-hook-trust")
+}
+
 func appendApprovalFlags(cmd *[]string, permissions ports.PermissionMode) {
 	switch normalizePermissionMode(permissions) {
 	case ports.PermissionModeDefault:

backend/internal/adapters/agent/codex/codex_test.go

@@ -28,6 +28,7 @@ func TestGetLaunchCommandBuildsCrossPlatformArgv(t *testing.T) {
 	want := []string{
 		"codex",
 		"-c", "check_for_update_on_startup=false",
+		"--dangerously-bypass-hook-trust",
 		"--dangerously-bypass-approvals-and-sandbox",
 		"-c", "model_instructions_file=" + filepath.Join("tmp", "prompt with spaces.md"),
 		"--", "-fix this",
@@ -249,6 +250,7 @@ func TestGetRestoreCommandReadsAgentSessionID(t *testing.T) {
 		"codex",
 		"resume",
 		"-c", "check_for_update_on_startup=false",
+		"--dangerously-bypass-hook-trust",
 		"--ask-for-approval", "on-request",
 		"-c", `approvals_reviewer="auto_review"`,
 		"thread-123",

backend/internal/adapters/agent/codex/hooks.go

@@ -34,7 +34,7 @@ type codexHookFile struct {
 }
 
 type codexMatcherGroup struct {
-	Matcher *string          `json:"matcher"`
+	Matcher *string          `json:"matcher,omitempty"`
 	Hooks   []codexHookEntry `json:"hooks"`
 }
 
@@ -56,6 +56,7 @@ type codexHookSpec struct {
 var codexManagedHooks = []codexHookSpec{
 	{Event: "SessionStart", Command: codexHookCommandPrefix + "session-start"},
 	{Event: "UserPromptSubmit", Command: codexHookCommandPrefix + "user-prompt-submit"},
+	{Event: "PermissionRequest", Command: codexHookCommandPrefix + "permission-request"},
 	{Event: "Stop", Command: codexHookCommandPrefix + "stop"},
 }
 

backend/internal/adapters/agent/opencode/activity.go

@@ -0,0 +1,18 @@
+package opencode
+
+import "github.com/aoagents/agent-orchestrator/backend/internal/domain"
+
+// DeriveActivityState maps an opencode plugin hook event onto an AO activity
+// state. The bool is false when the event carries no activity signal.
+func DeriveActivityState(event string, _ []byte) (domain.ActivityState, bool) {
+	switch event {
+	case "session-start":
+		return domain.ActivityActive, true
+	case "user-prompt-submit":
+		return domain.ActivityActive, true
+	case "stop":
+		return domain.ActivityIdle, true
+	default:
+		return "", false
+	}
+}

backend/internal/adapters/agent/opencode/activity_test.go

@@ -0,0 +1,30 @@
+package opencode
+
+import (
+	"testing"
+
+	"github.com/aoagents/agent-orchestrator/backend/internal/domain"
+)
+
+func TestDeriveActivityState(t *testing.T) {
+	tests := []struct {
+		name   string
+		event  string
+		want   domain.ActivityState
+		wantOK bool
+	}{
+		{"session start -> active", "session-start", domain.ActivityActive, true},
+		{"user prompt -> active", "user-prompt-submit", domain.ActivityActive, true},
+		{"stop -> idle", "stop", domain.ActivityIdle, true},
+		{"unknown event -> no signal", "frobnicate", "", false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, ok := DeriveActivityState(tt.event, []byte(`{}`))
+			if got != tt.want || ok != tt.wantOK {
+				t.Fatalf("DeriveActivityState(%q) = (%q, %v), want (%q, %v)",
+					tt.event, got, ok, tt.want, tt.wantOK)
+			}
+		})
+	}
+}

backend/internal/cli/client.go

@@ -93,7 +93,7 @@ func (c *commandContext) doJSON(ctx context.Context, method, path string, body,
 		reader = bytes.NewReader(payload)
 	}
 	url := fmt.Sprintf("http://%s:%d/api/v1/%s", config.LoopbackHost, info.Port, path)
-	req, err := http.NewRequestWithContext(ctx, method, url, reader)
+	req, err := http.NewRequestWithContext(ctx, method, url, reader) // #nosec G704 -- daemon host is fixed loopback; path is an internal API route.
 	if err != nil {
 		return err
 	}
@@ -105,7 +105,7 @@ func (c *commandContext) doJSON(ctx context.Context, method, path string, body,
 	// give daemon API calls far more headroom than the 2s status-probe timeout.
 	client := *c.deps.HTTPClient
 	client.Timeout = commandTimeout
-	resp, err := client.Do(req)
+	resp, err := client.Do(req) // #nosec G704 -- request target is the fixed loopback daemon URL above.
 	if err != nil {
 		return fmt.Errorf("call daemon: %w", err)
 	}