Merge PR #70 (feat(daemon): wire SM + agent shim + RepoResolver + inbox messenger, aa-39) into staging

Author: harshitsinghbhandari

backend/internal/adapters/agent/agent.go

@@ -30,6 +30,12 @@ type Agent interface {
 	SessionInfo(ctx context.Context, session SessionRef) (info SessionInfo, ok bool, err error)
 }
 
+// MetadataKeyAgentSessionID is the SessionRef.Metadata key under which every
+// adapter persists the native agent session id captured at launch and reads it
+// back during restore. The Better-AO portshim sets it so the underlying
+// adapter's GetRestoreCommand sees a unified location regardless of harness.
+const MetadataKeyAgentSessionID = "agentSessionId"
+
 // Config contains values loaded from the selected agent's config section.
 // Agent adapters own validation for their custom keys.
 type Config map[string]any

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

@@ -41,10 +41,8 @@ const (
 	// Normalized session-metadata keys the Claude Code hooks persist into the
 	// Better-AO session store and SessionInfo reads back. Shared vocabulary
 	// with the Codex adapter so the dashboard treats every agent uniformly.
-	// agentSessionId is also the preferred restore id.
-	claudeAgentSessionIDMetadataKey = "agentSessionId"
-	claudeTitleMetadataKey          = "title"
-	claudeSummaryMetadataKey        = "summary"
+	claudeTitleMetadataKey   = "title"
+	claudeSummaryMetadataKey = "summary"
 )
 
 // claudeSessionNamespace seeds the UUIDv5 derivation that maps a better-ao
@@ -179,7 +177,7 @@ func (p *Plugin) GetRestoreCommand(ctx context.Context, cfg agent.RestoreConfig)
 		return nil, false, err
 	}
 
-	sessionID := strings.TrimSpace(cfg.Session.Metadata[claudeAgentSessionIDMetadataKey])
+	sessionID := strings.TrimSpace(cfg.Session.Metadata[agent.MetadataKeyAgentSessionID])
 	if sessionID == "" && cfg.Session.ID != "" {
 		// Explicit fallback for pre-hook sessions: the id better-ao
 		// deterministically pinned via --session-id at launch.
@@ -210,7 +208,7 @@ func (p *Plugin) SessionInfo(ctx context.Context, session agent.SessionRef) (age
 		return agent.SessionInfo{}, false, err
 	}
 	info := agent.SessionInfo{
-		AgentSessionID: session.Metadata[claudeAgentSessionIDMetadataKey],
+		AgentSessionID: session.Metadata[agent.MetadataKeyAgentSessionID],
 		Title:          session.Metadata[claudeTitleMetadataKey],
 		Summary:        session.Metadata[claudeSummaryMetadataKey],
 	}

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

@@ -228,7 +228,7 @@ func TestSessionInfoReadsHookMetadata(t *testing.T) {
 	info, ok, err := (&Plugin{resolvedBinary: "claude"}).SessionInfo(context.Background(), agent.SessionRef{
 		WorkspacePath: "/some/path",
 		Metadata: map[string]string{
-			claudeAgentSessionIDMetadataKey: "claude-native-1",
+			agent.MetadataKeyAgentSessionID: "claude-native-1",
 			claudeTitleMetadataKey:          "Fix login redirect",
 			claudeSummaryMetadataKey:        "Updated the auth callback and tests.",
 			"ignored":                       "not returned",
@@ -299,7 +299,7 @@ func TestGetRestoreCommandReadsAgentSessionID(t *testing.T) {
 		Permissions: agent.PermissionModeBypassPermissions,
 		Session: agent.SessionRef{
 			ID:       "sess-r",
-			Metadata: map[string]string{claudeAgentSessionIDMetadataKey: "claude-native-1"},
+			Metadata: map[string]string{agent.MetadataKeyAgentSessionID: "claude-native-1"},
 		},
 	})
 	if err != nil || !ok {
@@ -334,7 +334,7 @@ func TestGetRestoreCommandFalseWithoutSessionID(t *testing.T) {
 		ref  agent.SessionRef
 	}{
 		{"empty ref", agent.SessionRef{}},
-		{"blank agent session, no id", agent.SessionRef{Metadata: map[string]string{claudeAgentSessionIDMetadataKey: "   "}}},
+		{"blank agent session, no id", agent.SessionRef{Metadata: map[string]string{agent.MetadataKeyAgentSessionID: "   "}}},
 		{"workspace path only", agent.SessionRef{WorkspacePath: "/some/path"}},
 	}
 	for _, tc := range cases {

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

@@ -20,7 +20,7 @@ import (
 )
 
 const (
-	codexAgentSessionIDMetadataKey = "agentSessionId"
+	codexAgentSessionIDMetadataKey = agent.MetadataKeyAgentSessionID
 	codexTitleMetadataKey          = "title"
 	codexSummaryMetadataKey        = "summary"
 )

backend/internal/adapters/agent/portshim/shim.go

@@ -0,0 +1,114 @@
+// Package portshim bridges the richer adapters/agent.Agent interface onto the
+// narrower ports.Agent the Session Manager consumes. The richer interface
+// returns argv slices and takes a context; ports.Agent returns a single shell
+// string and is context-free. The shim joins argv with POSIX shell quoting so
+// the zellij runtime, which evaluates LaunchCommand under `sh -lc`, sees the
+// agent's argv intact.
+package portshim
+
+import (
+	"context"
+	"strings"
+
+	"github.com/aoagents/agent-orchestrator/backend/internal/adapters/agent"
+	"github.com/aoagents/agent-orchestrator/backend/internal/ports"
+)
+
+// Shim wraps an adapters/agent.Agent and satisfies ports.Agent. The shim is
+// context-free at its API surface; it threads context.Background() into the
+// richer interface. That matches the existing ports.Agent shape — extending it
+// is a separate change.
+type Shim struct {
+	agent agent.Agent
+}
+
+// New constructs a Shim. agent is required; nil is not supported.
+func New(a agent.Agent) *Shim { return &Shim{agent: a} }
+
+var _ ports.Agent = (*Shim)(nil)
+
+// GetLaunchCommand asks the wrapped agent for its launch argv and renders it as
+// a single POSIX-shell-safe string. An adapter error or empty argv yields "".
+func (s *Shim) GetLaunchCommand(cfg ports.AgentConfig) string {
+	argv, err := s.agent.GetLaunchCommand(context.Background(), launchConfigFor(cfg))
+	if err != nil {
+		return ""
+	}
+	return joinShellArgv(argv)
+}
+
+// GetEnvironment returns nil: the richer agent interface doesn't carry the env
+// keys ports.AgentConfig exposes, and the SM layers AO_SESSION_ID,
+// AO_PROJECT_ID, AO_ISSUE_ID on top of whatever the agent contributes. A nil
+// map is fine here — session.spawnEnv treats nil as empty.
+func (s *Shim) GetEnvironment(ports.AgentConfig) map[string]string {
+	return nil
+}
+
+// GetRestoreCommand resumes a native agent session given its agentSessionID and
+// returns the resume command as a POSIX-shell-safe string. An adapter error or
+// ok=false yields "" — the SM falls back to a fresh Spawn.
+func (s *Shim) GetRestoreCommand(agentSessionID string) string {
+	cfg := agent.RestoreConfig{
+		Session: agent.SessionRef{
+			ID: agentSessionID,
+			Metadata: map[string]string{
+				agent.MetadataKeyAgentSessionID: agentSessionID,
+			},
+		},
+	}
+	argv, ok, err := s.agent.GetRestoreCommand(context.Background(), cfg)
+	if err != nil || !ok {
+		return ""
+	}
+	return joinShellArgv(argv)
+}
+
+func launchConfigFor(cfg ports.AgentConfig) agent.LaunchConfig {
+	return agent.LaunchConfig{
+		SessionID:     string(cfg.SessionID),
+		WorkspacePath: cfg.WorkspacePath,
+		Prompt:        cfg.Prompt,
+	}
+}
+
+// joinShellArgv renders argv as a single string the POSIX shell will re-parse
+// into the same tokens. Each arg is quoted in single quotes unless it consists
+// only of characters guaranteed safe to leave bare.
+func joinShellArgv(argv []string) string {
+	if len(argv) == 0 {
+		return ""
+	}
+	parts := make([]string, len(argv))
+	for i, a := range argv {
+		parts[i] = shellQuote(a)
+	}
+	return strings.Join(parts, " ")
+}
+
+func shellQuote(s string) string {
+	if s == "" {
+		return "''"
+	}
+	if isShellSafe(s) {
+		return s
+	}
+	return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
+}
+
+// isShellSafe matches the conservative bash-completion convention: letters,
+// digits, and a handful of punctuation that never trigger expansion or word
+// splitting. Anything else is quoted.
+func isShellSafe(s string) bool {
+	for _, r := range s {
+		switch {
+		case r >= 'a' && r <= 'z',
+			r >= 'A' && r <= 'Z',
+			r >= '0' && r <= '9',
+			r == '-', r == '_', r == '/', r == '.', r == ',', r == ':', r == '+', r == '@', r == '=':
+			continue
+		}
+		return false
+	}
+	return true
+}

backend/internal/adapters/agent/portshim/shim_test.go

@@ -0,0 +1,164 @@
+package portshim_test
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/aoagents/agent-orchestrator/backend/internal/adapters/agent"
+	"github.com/aoagents/agent-orchestrator/backend/internal/adapters/agent/portshim"
+	"github.com/aoagents/agent-orchestrator/backend/internal/ports"
+	"github.com/aoagents/agent-orchestrator/backend/internal/session"
+)
+
+type fakeAgent struct {
+	launchCmd     []string
+	launchErr     error
+	restoreCmd    []string
+	restoreOK     bool
+	restoreErr    error
+	gotLaunchCfg  agent.LaunchConfig
+	gotRestoreCfg agent.RestoreConfig
+}
+
+func (f *fakeAgent) GetConfigSpec(context.Context) (agent.ConfigSpec, error) {
+	return agent.ConfigSpec{}, nil
+}
+func (f *fakeAgent) GetLaunchCommand(_ context.Context, cfg agent.LaunchConfig) ([]string, error) {
+	f.gotLaunchCfg = cfg
+	return f.launchCmd, f.launchErr
+}
+func (f *fakeAgent) GetPromptDeliveryStrategy(context.Context, agent.LaunchConfig) (agent.PromptDeliveryStrategy, error) {
+	return agent.PromptDeliveryInCommand, nil
+}
+func (f *fakeAgent) GetAgentHooks(context.Context, agent.WorkspaceHookConfig) error { return nil }
+func (f *fakeAgent) GetRestoreCommand(_ context.Context, cfg agent.RestoreConfig) ([]string, bool, error) {
+	f.gotRestoreCfg = cfg
+	return f.restoreCmd, f.restoreOK, f.restoreErr
+}
+func (f *fakeAgent) SessionInfo(context.Context, agent.SessionRef) (agent.SessionInfo, bool, error) {
+	return agent.SessionInfo{}, false, nil
+}
+
+func TestSatisfiesPortsAgent(t *testing.T) {
+	var _ ports.Agent = (*portshim.Shim)(nil)
+}
+
+func TestGetLaunchCommand_JoinsArgvShellSafely(t *testing.T) {
+	tests := []struct {
+		name string
+		argv []string
+		want string
+	}{
+		{"simple", []string{"claude"}, "claude"},
+		{"flags and prompt", []string{"claude", "--", "do it"}, "claude -- 'do it'"},
+		{"path with spaces", []string{"/Applications/My App/claude", "--flag"}, "'/Applications/My App/claude' --flag"},
+		{"prompt with single quote", []string{"claude", "--", "it's fine"}, `claude -- 'it'\''s fine'`},
+		{"empty argv", []string{}, ""},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			s := portshim.New(&fakeAgent{launchCmd: tc.argv})
+			got := s.GetLaunchCommand(ports.AgentConfig{})
+			if got != tc.want {
+				t.Fatalf("got %q want %q", got, tc.want)
+			}
+		})
+	}
+}
+
+func TestGetLaunchCommand_PropagatesAgentConfig(t *testing.T) {
+	fake := &fakeAgent{launchCmd: []string{"claude"}}
+	s := portshim.New(fake)
+	cfg := ports.AgentConfig{SessionID: "p-1", WorkspacePath: "/ws/p-1", Prompt: "hello"}
+	_ = s.GetLaunchCommand(cfg)
+	if fake.gotLaunchCfg.SessionID != "p-1" {
+		t.Errorf("SessionID not propagated: %+v", fake.gotLaunchCfg)
+	}
+	if fake.gotLaunchCfg.WorkspacePath != "/ws/p-1" {
+		t.Errorf("WorkspacePath not propagated: %+v", fake.gotLaunchCfg)
+	}
+	if fake.gotLaunchCfg.Prompt != "hello" {
+		t.Errorf("Prompt not propagated: %+v", fake.gotLaunchCfg)
+	}
+}
+
+func TestGetLaunchCommand_AgentErrorReturnsEmpty(t *testing.T) {
+	fake := &fakeAgent{launchErr: errors.New("boom")}
+	s := portshim.New(fake)
+	got := s.GetLaunchCommand(ports.AgentConfig{SessionID: "p-1"})
+	if got != "" {
+		t.Fatalf("expected empty on error, got %q", got)
+	}
+}
+
+func TestGetEnvironment_ReturnsAgentEnvKeysOnly(t *testing.T) {
+	// The richer Agent interface doesn't carry the env keys the SM port supplies,
+	// so the shim has nothing agent-specific to surface. SM layers AO_* on top.
+	s := portshim.New(&fakeAgent{})
+	got := s.GetEnvironment(ports.AgentConfig{SessionID: "p-1"})
+	if len(got) != 0 {
+		t.Fatalf("expected empty env from shim, got %v", got)
+	}
+	for _, k := range []string{session.EnvSessionID, session.EnvProjectID, session.EnvIssueID} {
+		if _, ok := got[k]; ok {
+			t.Errorf("shim must not pre-populate AO env key %s; SM owns it", k)
+		}
+	}
+}
+
+func TestGetRestoreCommand_JoinsWhenOK(t *testing.T) {
+	fake := &fakeAgent{restoreCmd: []string{"claude", "--resume", "abc 123"}, restoreOK: true}
+	s := portshim.New(fake)
+	got := s.GetRestoreCommand("abc 123")
+	want := `claude --resume 'abc 123'`
+	if got != want {
+		t.Fatalf("got %q want %q", got, want)
+	}
+	if fake.gotRestoreCfg.Session.ID != "abc 123" {
+		t.Errorf("session id not propagated: %+v", fake.gotRestoreCfg)
+	}
+}
+
+func TestGetRestoreCommand_NotOKReturnsEmpty(t *testing.T) {
+	fake := &fakeAgent{restoreOK: false}
+	s := portshim.New(fake)
+	if got := s.GetRestoreCommand("anything"); got != "" {
+		t.Fatalf("expected empty when not restorable, got %q", got)
+	}
+}
+
+func TestGetRestoreCommand_ErrorReturnsEmpty(t *testing.T) {
+	fake := &fakeAgent{restoreErr: errors.New("boom")}
+	s := portshim.New(fake)
+	if got := s.GetRestoreCommand("x"); got != "" {
+		t.Fatalf("expected empty on restore error, got %q", got)
+	}
+}
+
+func TestGetRestoreCommand_PassesAgentSessionIDAsMetadata(t *testing.T) {
+	// Claude-code (and Codex) read the native session id off cfg.Session.Metadata
+	// ["agentSessionId"] to rebuild the --resume command. Pass it via both Session.ID
+	// (the legacy fallback) and Session.Metadata so the richer adapter can find it.
+	fake := &fakeAgent{restoreCmd: []string{"claude", "--resume", "x"}, restoreOK: true}
+	s := portshim.New(fake)
+	_ = s.GetRestoreCommand("native-uuid")
+	gotID := fake.gotRestoreCfg.Session.ID
+	if gotID != "native-uuid" {
+		t.Errorf("Session.ID want native-uuid, got %q", gotID)
+	}
+	if m := fake.gotRestoreCfg.Session.Metadata[agent.MetadataKeyAgentSessionID]; m != "native-uuid" {
+		t.Errorf("Session.Metadata[%s] want native-uuid, got %q", agent.MetadataKeyAgentSessionID, m)
+	}
+}
+
+func TestShellQuotingDoesNotDoubleQuoteSafeStrings(t *testing.T) {
+	// Safe identifiers (letters, digits, dash, dot, slash, underscore) should
+	// pass through unquoted; quoting them would inflate every command.
+	s := portshim.New(&fakeAgent{launchCmd: []string{"/usr/local/bin/claude", "--session-id", "abc-123_xyz.uuid"}})
+	got := s.GetLaunchCommand(ports.AgentConfig{})
+	if strings.Contains(got, "'") {
+		t.Fatalf("got unexpected quotes: %q", got)
+	}
+}