diff --git a/apps/backend/internal/agent/runtime/lifecycle/profile_resolver_test.go b/apps/backend/internal/agent/runtime/lifecycle/profile_resolver_test.go
index c27bb9bf1e..a13e328856 100644
--- a/apps/backend/internal/agent/runtime/lifecycle/profile_resolver_test.go
+++ b/apps/backend/internal/agent/runtime/lifecycle/profile_resolver_test.go
@@ -75,6 +75,11 @@ func (m *MockRepository) CreateAgentProfile(ctx context.Context, profile *models
return nil
}
+// DuplicateAgentProfile implements the settings store interface for the resolver test fakes.
+func (m *MockRepository) DuplicateAgentProfile(ctx context.Context, input store.DuplicateAgentProfileInput) error {
+ return nil
+}
+
func (m *MockRepository) UpdateAgentProfile(ctx context.Context, profile *models.AgentProfile) error {
if m.updateAgentProfileFn != nil {
return m.updateAgentProfileFn(ctx, profile)
diff --git a/apps/backend/internal/agent/settings/controller/profile_crud.go b/apps/backend/internal/agent/settings/controller/profile_crud.go
index 946e0d0703..1ee348fa41 100644
--- a/apps/backend/internal/agent/settings/controller/profile_crud.go
+++ b/apps/backend/internal/agent/settings/controller/profile_crud.go
@@ -2,6 +2,8 @@ package controller
import (
"context"
+ "database/sql"
+ "errors"
"fmt"
"regexp"
"sort"
@@ -14,6 +16,7 @@ import (
"github.com/kandev/kandev/internal/agent/settings/dto"
"github.com/kandev/kandev/internal/agent/settings/models"
"github.com/kandev/kandev/internal/agent/settings/profileconfig"
+ "github.com/kandev/kandev/internal/agent/settings/store"
"github.com/kandev/kandev/internal/secrets"
)
@@ -254,6 +257,212 @@ func (c *Controller) UpdateProfile(ctx context.Context, req UpdateProfileRequest
return &result, nil
}
+type DuplicateProfileRequest struct {
+ ID string
+}
+
+// DuplicateProfile creates an independent copy of an existing profile. The
+// copy keeps every configuration field (model, mode, config options, CLI
+// flags, env vars, launcher prefix, auto-approve flags, enabled state, MCP
+// config) under a fresh row named " Copy", so a user can start a
+// variant from a working profile without re-entering it. Runtime state is
+// intentionally not copied: the copy starts idle with no pause reason,
+// last-run timestamp, or consecutive-failure count. No in-use checks apply —
+// a brand-new row cannot be referenced by sessions, watchers, automations,
+// or routing tiers yet.
+//
+// The copy is committed in one repository transaction (row + MCP config), so
+// a failure leaves no partial profile and a disabled source never becomes
+// briefly selectable.
+//
+// The source profile and MCP row are read up front, then the repository
+// re-verifies those revisions inside the transaction; a concurrent writer
+// between the reads and the insert aborts with a retryable error, so the
+// copy always reflects one consistent snapshot of the source.
+func (c *Controller) DuplicateProfile(ctx context.Context, req DuplicateProfileRequest) (*dto.AgentProfileDTO, error) {
+ source, err := c.repo.GetAgentProfile(ctx, req.ID)
+ if err != nil {
+ if isProfileNotFoundErr(err) {
+ return nil, ErrAgentProfileNotFound
+ }
+ return nil, err
+ }
+ // Office-scoped profiles are owned by the workspace-scoped office API
+ // surface and hidden from this instance-level settings surface (the UI
+ // filters them via filterGlobalProfiles). Refuse to duplicate them here so
+ // the endpoint cannot read or clone another workspace's configuration;
+ // 404 keeps the existence of office profiles hidden.
+ if source.WorkspaceID != "" {
+ return nil, ErrAgentProfileNotFound
+ }
+ for attempt := 0; ; attempt++ {
+ // A source without an MCP row leaves the copy without one: the
+ // default-config semantics and boot EnsureDefaultMcpConfig cover
+ // MCP-supporting agents.
+ var sourceMcp *models.AgentProfileMcpConfig
+ sourceMcp, err = c.repo.GetAgentProfileMcpConfig(ctx, source.ID)
+ if err != nil && !errors.Is(err, sql.ErrNoRows) {
+ return nil, err
+ }
+ if errors.Is(err, sql.ErrNoRows) {
+ sourceMcp = nil
+ }
+ clone := duplicateClone(source)
+ var mcpCopy *models.AgentProfileMcpConfig
+ if sourceMcp != nil {
+ mcpCopy = &models.AgentProfileMcpConfig{
+ Enabled: sourceMcp.Enabled,
+ Servers: cloneStringInterfaceMap(sourceMcp.Servers),
+ Meta: cloneStringInterfaceMap(sourceMcp.Meta),
+ }
+ }
+ err = c.repo.DuplicateAgentProfile(ctx, store.DuplicateAgentProfileInput{
+ Source: source,
+ SourceMcp: sourceMcp,
+ Profile: clone,
+ McpConfig: mcpCopy,
+ })
+ if err == nil {
+ result := toProfileDTO(clone)
+ return &result, nil
+ }
+ // A source deleted between the snapshot read and the transaction is a
+ // deterministic 404, not a retryable race: the copy has nothing to
+ // reflect, so surface it immediately instead of re-reading the source
+ // up to maxDuplicateRetries times.
+ if errors.Is(err, store.ErrSourceProfileNotFound) {
+ return nil, ErrAgentProfileNotFound
+ }
+ if !isRetryableDuplicateErr(err) || attempt >= maxDuplicateRetries {
+ return nil, err
+ }
+ source, err = c.repo.GetAgentProfile(ctx, req.ID)
+ if err != nil {
+ if isProfileNotFoundErr(err) {
+ return nil, ErrAgentProfileNotFound
+ }
+ return nil, err
+ }
+ }
+}
+
+// maxDuplicateRetries bounds the number of re-attempts after a concurrent
+// source change. One retry covers the common single-writer race; the cap
+// prevents a hot loop under sustained concurrent edits.
+const maxDuplicateRetries = 2
+
+// isRetryableDuplicateErr reports whether a duplicate attempt failed because
+// the source changed concurrently (revision mismatch or a WAL snapshot-isolation
+// busy error on the write) rather than deterministically. A deleted source is
+// intentionally absent: DuplicateProfile maps ErrSourceProfileNotFound to 404
+// before consulting this set.
+func isRetryableDuplicateErr(err error) bool {
+ return errors.Is(err, store.ErrProfileChanged) ||
+ strings.Contains(err.Error(), "database is locked") ||
+ strings.Contains(err.Error(), "database table is locked")
+}
+
+// duplicateClone builds the copy row from the source profile. Runtime state
+// is intentionally not copied: the copy starts idle with no pause reason,
+// last-run timestamp, or consecutive-failure count.
+func duplicateClone(source *models.AgentProfile) *models.AgentProfile {
+ return &models.AgentProfile{
+ AgentID: source.AgentID,
+ Name: strings.TrimSpace(source.Name) + " Copy",
+ AgentDisplayName: source.AgentDisplayName,
+ Model: source.Model,
+ FallbackModel: strings.TrimSpace(source.FallbackModel),
+ AutoFallback: source.AutoFallback,
+ Mode: source.Mode,
+ ConfigOptions: profileconfig.SanitizeConfigOptions(cloneStringMap(source.ConfigOptions)),
+ AllowIndexing: source.AllowIndexing,
+ AutoApprove: source.AutoApprove,
+ CLIPassthrough: source.CLIPassthrough,
+ CLIFlags: cloneCLIFlags(source.CLIFlags),
+ EnvVars: cloneEnvVars(source.EnvVars),
+ CommandPrefix: source.CommandPrefix,
+ UserModified: true,
+ Enabled: source.Enabled,
+ WorkspaceID: source.WorkspaceID,
+ Role: source.Role,
+ Icon: source.Icon,
+ ReportsTo: source.ReportsTo,
+ SkillIDs: source.SkillIDs,
+ DesiredSkills: source.DesiredSkills,
+ MaxConcurrentSessions: source.MaxConcurrentSessions,
+ CooldownSec: source.CooldownSec,
+ SkipIdleRuns: source.SkipIdleRuns,
+ FailureThreshold: cloneIntPtr(source.FailureThreshold),
+ ExecutorPreference: source.ExecutorPreference,
+ BudgetMonthlyCents: source.BudgetMonthlyCents,
+ Settings: source.Settings,
+ Permissions: source.Permissions,
+ DangerouslySkipPermissions: source.DangerouslySkipPermissions,
+ CustomPrompt: source.CustomPrompt,
+ }
+}
+
+// isProfileNotFoundErr reports whether err means "no live profile row with
+// that ID". The sqlite store surfaces it as sql.ErrNoRows from GetAgentProfile
+// and as an "agent profile not found" message from the update/delete paths;
+// fakes and future stores may use either shape.
+func isProfileNotFoundErr(err error) bool {
+ return errors.Is(err, sql.ErrNoRows) || strings.Contains(err.Error(), "agent profile not found")
+}
+
+// cloneCLIFlags returns a copy of the profile's CLI flag list so the
+// duplicated profile never shares slice memory with the source.
+func cloneCLIFlags(in []models.CLIFlag) []models.CLIFlag {
+ out := make([]models.CLIFlag, len(in))
+ copy(out, in)
+ return out
+}
+
+// cloneEnvVars returns a copy of the profile's env-var list (secret
+// references included) so the duplicated profile never shares slice memory
+// with the source.
+func cloneEnvVars(in []models.ProfileEnvVar) []models.ProfileEnvVar {
+ out := make([]models.ProfileEnvVar, len(in))
+ copy(out, in)
+ return out
+}
+
+// cloneStringMap returns a shallow copy of a string map, preserving nil so a
+// source with no config options stays nil on the copy.
+func cloneStringMap(in map[string]string) map[string]string {
+ if in == nil {
+ return nil
+ }
+ out := make(map[string]string, len(in))
+ for k, v := range in {
+ out[k] = v
+ }
+ return out
+}
+
+// cloneStringInterfaceMap returns a shallow copy of a string-keyed interface
+// map (used for MCP servers/meta), preserving nil.
+func cloneStringInterfaceMap(in map[string]interface{}) map[string]interface{} {
+ if in == nil {
+ return nil
+ }
+ out := make(map[string]interface{}, len(in))
+ for k, v := range in {
+ out[k] = v
+ }
+ return out
+}
+
+// cloneIntPtr returns a copy of an int pointer so the duplicated profile never
+// aliases the source's field, preserving nil.
+func cloneIntPtr(in *int) *int {
+ if in == nil {
+ return nil
+ }
+ v := *in
+ return &v
+}
+
func (c *Controller) validateGlobalSecretRefs(ctx context.Context, envVars []dto.ProfileEnvVarDTO) error {
if c.secretStore == nil {
return nil
diff --git a/apps/backend/internal/agent/settings/controller/profile_duplicate_test.go b/apps/backend/internal/agent/settings/controller/profile_duplicate_test.go
new file mode 100644
index 0000000000..96e9cb927c
--- /dev/null
+++ b/apps/backend/internal/agent/settings/controller/profile_duplicate_test.go
@@ -0,0 +1,369 @@
+package controller
+
+import (
+ "context"
+ "errors"
+ "testing"
+ "time"
+
+ "github.com/kandev/kandev/internal/agent/settings/models"
+ "github.com/kandev/kandev/internal/agent/settings/store"
+)
+
+// sourceProfile returns a fully-populated kanban-flavour profile so every
+// copy assertion has a concrete value to compare against.
+func sourceProfile() *models.AgentProfile {
+ failureThreshold := 4
+ lastRun := time.Date(2026, 8, 1, 12, 0, 0, 0, time.UTC)
+ return &models.AgentProfile{
+ ID: "source-1",
+ AgentID: "agent-1",
+ Name: "Default",
+ AgentDisplayName: "Claude Code",
+ Model: "claude-sonnet",
+ FallbackModel: "claude-haiku",
+ AutoFallback: true,
+ Mode: "plan",
+ ConfigOptions: map[string]string{"effort": "high"},
+ AllowIndexing: true,
+ AutoApprove: true,
+ CLIPassthrough: true,
+ CLIFlags: []models.CLIFlag{
+ {Description: "Allow all tools", Flag: "--allow-all-tools", Enabled: true},
+ {Description: "Custom", Flag: "--my-flag value", Enabled: false},
+ },
+ EnvVars: []models.ProfileEnvVar{
+ {Key: "FOO", Value: "bar"},
+ {Key: "TOKEN", SecretID: "sec-1"},
+ },
+ CommandPrefix: "greywall --",
+ UserModified: true,
+ Enabled: true,
+ // Office enrichment configuration — must be copied. WorkspaceID stays
+ // empty (kanban): the settings duplicate endpoint rejects office-scoped
+ // sources, so the copy assertions cover the enrichment fields on a
+ // kanban-scoped profile.
+ WorkspaceID: "",
+ Role: "worker",
+ Icon: "🤖",
+ ReportsTo: "profile-other",
+ SkillIDs: `["s1","s2"]`,
+ DesiredSkills: `["ds1"]`,
+ MaxConcurrentSessions: 2,
+ CooldownSec: 60,
+ SkipIdleRuns: true,
+ FailureThreshold: &failureThreshold,
+ ExecutorPreference: "exec-local",
+ BudgetMonthlyCents: 12500,
+ Settings: `{"office_theme":"dark"}`,
+ Permissions: `{"spawn_subagents":true}`,
+ // Deprecated legacy columns — still copied for fidelity so an old row's
+ // values survive duplication.
+ DangerouslySkipPermissions: true,
+ CustomPrompt: "legacy prompt",
+ // Runtime state — must NOT be copied.
+ Status: "working",
+ PauseReason: "auto-paused",
+ LastRunFinishedAt: &lastRun,
+ ConsecutiveFailures: 3,
+ }
+}
+
+// duplicateSetup wires a controller to a fake store pre-seeded with the source profile.
+func duplicateSetup(source *models.AgentProfile) (*Controller, *fakeStore) {
+ ctrl := newTestController(nil)
+ st := newFakeStore()
+ st.agents[source.AgentID] = &models.Agent{ID: source.AgentID, Name: "test-agent"}
+ st.profiles[source.AgentID] = []*models.AgentProfile{source}
+ ctrl.repo = st
+ return ctrl, st
+}
+
+// TestDuplicateProfile_CopiesFullConfiguration verifies every configuration field (office enrichment and deprecated legacy columns included) survives duplication while runtime state is reset.
+func TestDuplicateProfile_CopiesFullConfiguration(t *testing.T) {
+ source := sourceProfile()
+ ctrl, st := duplicateSetup(source)
+
+ result, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID})
+ if err != nil {
+ t.Fatalf("DuplicateProfile: %v", err)
+ }
+
+ if result.ID == source.ID || result.ID == "" {
+ t.Fatalf("copy ID = %q, want a fresh non-empty ID", result.ID)
+ }
+ if result.Name != "Default Copy" {
+ t.Errorf("copy name = %q, want %q", result.Name, "Default Copy")
+ }
+ if result.AgentID != source.AgentID {
+ t.Errorf("copy agent_id = %q, want %q", result.AgentID, source.AgentID)
+ }
+ if result.AgentDisplayName != source.AgentDisplayName {
+ t.Errorf("copy display name = %q, want %q", result.AgentDisplayName, source.AgentDisplayName)
+ }
+ if result.Model != source.Model || result.FallbackModel != source.FallbackModel || !result.AutoFallback {
+ t.Errorf("copy model fields = (%q, %q, %v), want (%q, %q, true)",
+ result.Model, result.FallbackModel, result.AutoFallback, source.Model, source.FallbackModel)
+ }
+ if result.Mode != source.Mode {
+ t.Errorf("copy mode = %q, want %q", result.Mode, source.Mode)
+ }
+ if len(result.ConfigOptions) != 1 || result.ConfigOptions["effort"] != "high" {
+ t.Errorf("copy config options = %+v, want effort=high", result.ConfigOptions)
+ }
+ if !result.AllowIndexing || !result.AutoApprove || !result.CLIPassthrough {
+ t.Errorf("copy boolean config not preserved: allow_indexing=%v auto_approve=%v cli_passthrough=%v",
+ result.AllowIndexing, result.AutoApprove, result.CLIPassthrough)
+ }
+ if !result.UserModified {
+ t.Error("copy user_modified = false, want true")
+ }
+ if !result.Enabled {
+ t.Error("copy enabled = false, want true (source enabled)")
+ }
+ if result.CommandPrefix != "greywall --" {
+ t.Errorf("copy command prefix = %q, want %q", result.CommandPrefix, "greywall --")
+ }
+ if len(result.CLIFlags) != 2 ||
+ result.CLIFlags[0].Flag != "--allow-all-tools" || !result.CLIFlags[0].Enabled ||
+ result.CLIFlags[1].Flag != "--my-flag value" || result.CLIFlags[1].Enabled {
+ t.Errorf("copy cli flags = %+v, want both source entries with their enabled states", result.CLIFlags)
+ }
+ if len(result.EnvVars) != 2 ||
+ result.EnvVars[0].Key != "FOO" || result.EnvVars[0].Value != "bar" || result.EnvVars[0].SecretID != "" ||
+ result.EnvVars[1].Key != "TOKEN" || result.EnvVars[1].SecretID != "sec-1" {
+ t.Errorf("copy env vars = %+v, want both source entries incl. secret ref", result.EnvVars)
+ }
+
+ if len(st.created) != 1 {
+ t.Fatalf("stored copies = %d, want 1", len(st.created))
+ }
+ stored := st.created[0]
+ if stored.ID != result.ID {
+ t.Errorf("stored copy ID = %q, response ID = %q", stored.ID, result.ID)
+ }
+ // Office enrichment configuration copied; runtime state reset.
+ if stored.WorkspaceID != "" || stored.Role != "worker" || stored.Icon != "🤖" ||
+ stored.ReportsTo != "profile-other" || stored.SkillIDs != `["s1","s2"]` ||
+ stored.DesiredSkills != `["ds1"]` || stored.MaxConcurrentSessions != 2 ||
+ stored.CooldownSec != 60 || !stored.SkipIdleRuns ||
+ stored.FailureThreshold == nil || *stored.FailureThreshold != 4 ||
+ stored.ExecutorPreference != "exec-local" || stored.BudgetMonthlyCents != 12500 ||
+ stored.Settings != `{"office_theme":"dark"}` || stored.Permissions != `{"spawn_subagents":true}` {
+ t.Errorf("stored office enrichment not copied: %+v", stored)
+ }
+ if !stored.DangerouslySkipPermissions || stored.CustomPrompt != "legacy prompt" {
+ t.Errorf("deprecated legacy columns not copied: dangerously_skip_permissions=%v custom_prompt=%q",
+ stored.DangerouslySkipPermissions, stored.CustomPrompt)
+ }
+ if stored.Status != "" || stored.PauseReason != "" || stored.LastRunFinishedAt != nil || stored.ConsecutiveFailures != 0 {
+ t.Errorf("runtime state must not be copied: status=%q pause=%q last_run=%v failures=%d",
+ stored.Status, stored.PauseReason, stored.LastRunFinishedAt, stored.ConsecutiveFailures)
+ }
+ if stored.MigratedFrom != "" {
+ t.Errorf("legacy field must not be copied: migrated_from=%q", stored.MigratedFrom)
+ }
+}
+
+// TestDuplicateProfile_CopiesDisabledState verifies a disabled source produces a disabled copy.
+func TestDuplicateProfile_CopiesDisabledState(t *testing.T) {
+ source := sourceProfile()
+ source.Enabled = false
+ ctrl, st := duplicateSetup(source)
+
+ result, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID})
+ if err != nil {
+ t.Fatalf("DuplicateProfile: %v", err)
+ }
+ if result.Enabled {
+ t.Error("copy enabled = true, want false (source disabled)")
+ }
+ if len(st.created) != 1 || st.created[0].Enabled {
+ t.Errorf("stored copy enabled = %v, want false", st.created[0].Enabled)
+ }
+ // The disabled state must be part of the single atomic duplicate write:
+ // no follow-up enabled flip is allowed (a flip would create a window where
+ // the copy is selectable and would need a second write).
+ if len(st.updated) != 0 {
+ t.Errorf("duplicate issued %d follow-up updates, want 0 (atomic write)", len(st.updated))
+ }
+ // The response timestamps must be the ones actually stored (no stale
+ // insert timestamp after a separate write).
+ stored := st.created[0]
+ if !result.CreatedAt.Equal(stored.CreatedAt) || !result.UpdatedAt.Equal(stored.UpdatedAt) {
+ t.Errorf("response timestamps (%v/%v) differ from stored (%v/%v)",
+ result.CreatedAt, result.UpdatedAt, stored.CreatedAt, stored.UpdatedAt)
+ }
+}
+
+// TestDuplicateProfile_StoreFailureLeavesNoCopy verifies a failed transaction leaves no copy behind.
+func TestDuplicateProfile_StoreFailureLeavesNoCopy(t *testing.T) {
+ source := sourceProfile()
+ ctrl, st := duplicateSetup(source)
+ wantErr := errors.New("boom")
+ st.duplicateProfErr = wantErr
+
+ _, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID})
+ if !errors.Is(err, wantErr) {
+ t.Fatalf("err = %v, want %v", err, wantErr)
+ }
+ if len(st.created) != 0 || len(st.mcpConfigs) != 0 {
+ t.Errorf("partial copy persisted despite store error: created=%d mcp=%d",
+ len(st.created), len(st.mcpConfigs))
+ }
+}
+
+// TestDuplicateProfile_CopiesMcpConfig verifies the MCP config (enabled, servers, meta) is copied under the new profile ID.
+func TestDuplicateProfile_CopiesMcpConfig(t *testing.T) {
+ source := sourceProfile()
+ ctrl, st := duplicateSetup(source)
+ st.mcpConfigs[source.ID] = &models.AgentProfileMcpConfig{
+ ProfileID: source.ID,
+ Enabled: true,
+ Servers: map[string]interface{}{
+ "github": map[string]interface{}{"url": "https://api.github.com", "enabled": true},
+ },
+ Meta: map[string]interface{}{"source": "user"},
+ }
+
+ result, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID})
+ if err != nil {
+ t.Fatalf("DuplicateProfile: %v", err)
+ }
+
+ copied, ok := st.mcpConfigs[result.ID]
+ if !ok {
+ t.Fatalf("no mcp config row for copy %q", result.ID)
+ }
+ if !copied.Enabled {
+ t.Error("copied mcp config enabled = false, want true")
+ }
+ servers, ok := copied.Servers["github"].(map[string]interface{})
+ if !ok || servers["url"] != "https://api.github.com" || servers["enabled"] != true {
+ t.Errorf("copied mcp servers = %+v, want github entry preserved", copied.Servers)
+ }
+ if copied.Meta["source"] != "user" {
+ t.Errorf("copied mcp meta = %+v, want source=user", copied.Meta)
+ }
+ // The source row must be untouched.
+ if _, ok := st.mcpConfigs[source.ID]; !ok {
+ t.Error("source mcp config row disappeared")
+ }
+}
+
+// TestDuplicateProfile_NoMcpConfigLeavesCopyWithoutRow verifies a source without an MCP row leaves the copy without one.
+func TestDuplicateProfile_NoMcpConfigLeavesCopyWithoutRow(t *testing.T) {
+ source := sourceProfile()
+ ctrl, st := duplicateSetup(source)
+
+ if _, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID}); err != nil {
+ t.Fatalf("DuplicateProfile: %v", err)
+ }
+ if len(st.mcpConfigs) != 0 {
+ t.Errorf("copy created an mcp config row when the source had none: %+v", st.mcpConfigs)
+ }
+}
+
+// TestDuplicateProfile_NotFound verifies an unknown source ID maps to ErrAgentProfileNotFound.
+func TestDuplicateProfile_NotFound(t *testing.T) {
+ ctrl, _ := duplicateSetup(sourceProfile())
+
+ _, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: "missing"})
+ if !errors.Is(err, ErrAgentProfileNotFound) {
+ t.Fatalf("err = %v, want ErrAgentProfileNotFound", err)
+ }
+}
+
+// TestDuplicateProfile_RejectsOfficeScopedSource verifies the settings
+// duplicate endpoint refuses office-scoped profiles: they are owned by the
+// workspace-scoped office surface and hidden from this instance-level API, so
+// duplication must fail closed (as 404, not 403, to keep their existence
+// hidden) without creating a copy.
+func TestDuplicateProfile_RejectsOfficeScopedSource(t *testing.T) {
+ source := sourceProfile()
+ source.WorkspaceID = "ws-1"
+ ctrl, st := duplicateSetup(source)
+
+ _, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID})
+ if !errors.Is(err, ErrAgentProfileNotFound) {
+ t.Fatalf("err = %v, want ErrAgentProfileNotFound for an office-scoped source", err)
+ }
+ if len(st.created) != 0 {
+ t.Errorf("office-scoped source created %d copies, want 0", len(st.created))
+ }
+}
+
+// TestDuplicateProfile_NameSuffixFromEmptySourceName pins the copy name when the source name is empty.
+func TestDuplicateProfile_NameSuffixFromEmptySourceName(t *testing.T) {
+ source := sourceProfile()
+ source.Name = ""
+ ctrl, st := duplicateSetup(source)
+
+ result, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID})
+ if err != nil {
+ t.Fatalf("DuplicateProfile: %v", err)
+ }
+ if result.Name != " Copy" {
+ t.Errorf("copy name = %q, want %q", result.Name, " Copy")
+ }
+ _ = st
+}
+
+// TestDuplicateProfile_RetriesOnConcurrentChange verifies the controller
+// re-reads the source and retries when the repository aborts the first
+// attempt with ErrProfileChanged (a concurrent writer), ending with exactly
+// one copy — and that the retried copy reflects the NEW source state (proving
+// the fresh GetAgentProfile happened).
+func TestDuplicateProfile_RetriesOnConcurrentChange(t *testing.T) {
+ source := sourceProfile()
+ ctrl, st := duplicateSetup(source)
+ st.duplicateChangedOnce = true
+
+ result, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID})
+ if err != nil {
+ t.Fatalf("DuplicateProfile after retry: %v", err)
+ }
+ if result.ID == source.ID || result.ID == "" {
+ t.Fatalf("copy ID = %q, want a fresh ID", result.ID)
+ }
+ if result.Name != "Changed Name Copy" {
+ t.Errorf("copy name = %q, want %q (copy must be built from the re-read source)", result.Name, "Changed Name Copy")
+ }
+ if len(st.created) != 1 {
+ t.Fatalf("stored copies = %d, want exactly 1 after retry", len(st.created))
+ }
+}
+
+// TestDuplicateProfile_ExhaustsRetriesOnPersistentChange verifies the
+// controller gives up (and creates nothing) when every attempt aborts with
+// ErrProfileChanged.
+func TestDuplicateProfile_ExhaustsRetriesOnPersistentChange(t *testing.T) {
+ source := sourceProfile()
+ ctrl, st := duplicateSetup(source)
+ st.duplicateProfErr = store.ErrProfileChanged
+
+ _, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID})
+ if !errors.Is(err, store.ErrProfileChanged) {
+ t.Fatalf("err = %v, want ErrProfileChanged", err)
+ }
+ if len(st.created) != 0 {
+ t.Errorf("copy created despite persistent source changes: %d rows", len(st.created))
+ }
+}
+
+// TestDuplicateProfile_SourceDeletedMidFlightMapsToNotFound verifies a source
+// deleted during the duplicate retries surfaces as ErrAgentProfileNotFound
+// (HTTP 404) instead of the raw store error (HTTP 500).
+func TestDuplicateProfile_SourceDeletedMidFlightMapsToNotFound(t *testing.T) {
+ source := sourceProfile()
+ ctrl, st := duplicateSetup(source)
+ st.duplicateProfErr = store.ErrSourceProfileNotFound
+
+ _, err := ctrl.DuplicateProfile(context.Background(), DuplicateProfileRequest{ID: source.ID})
+ if !errors.Is(err, ErrAgentProfileNotFound) {
+ t.Fatalf("err = %v, want ErrAgentProfileNotFound", err)
+ }
+ if len(st.created) != 0 {
+ t.Errorf("copy created despite deleted source: %d rows", len(st.created))
+ }
+}
diff --git a/apps/backend/internal/agent/settings/controller/reconciler_test.go b/apps/backend/internal/agent/settings/controller/reconciler_test.go
index 62b95e05f6..88021351db 100644
--- a/apps/backend/internal/agent/settings/controller/reconciler_test.go
+++ b/apps/backend/internal/agent/settings/controller/reconciler_test.go
@@ -17,6 +17,7 @@ import (
"github.com/kandev/kandev/internal/agent/hostutility"
"github.com/kandev/kandev/internal/agent/registry"
"github.com/kandev/kandev/internal/agent/settings/models"
+ "github.com/kandev/kandev/internal/agent/settings/store"
"github.com/kandev/kandev/internal/agent/usage"
"github.com/kandev/kandev/internal/agentctl/acpcompat"
"github.com/kandev/kandev/internal/common/logger"
@@ -34,26 +35,30 @@ func (f *fakeCapReader) Get(agentType string) (hostutility.AgentCapabilities, bo
// fakeStore implements just enough of store.Repository for the reconciler.
type fakeStore struct {
- agents map[string]*models.Agent // keyed by DB ID
- byName map[string]*models.Agent // keyed by Name
- profiles map[string][]*models.AgentProfile // keyed by DB agent ID (live)
- deleted map[string][]*models.AgentProfile // keyed by DB agent ID (soft-deleted)
- created []*models.AgentProfile
- updated []*models.AgentProfile
- softDeleted []string
- nextAgentID int
- nextProfID int
- getByNameErr error
- listAgentsErr error
- listProfErr map[string]error
+ agents map[string]*models.Agent // keyed by DB ID
+ byName map[string]*models.Agent // keyed by Name
+ profiles map[string][]*models.AgentProfile // keyed by DB agent ID (live)
+ deleted map[string][]*models.AgentProfile // keyed by DB agent ID (soft-deleted)
+ mcpConfigs map[string]*models.AgentProfileMcpConfig // keyed by profile ID
+ created []*models.AgentProfile
+ updated []*models.AgentProfile
+ softDeleted []string
+ nextAgentID int
+ nextProfID int
+ getByNameErr error
+ listAgentsErr error
+ listProfErr map[string]error
+ duplicateProfErr error
+ duplicateChangedOnce bool
}
func newFakeStore() *fakeStore {
return &fakeStore{
- agents: map[string]*models.Agent{},
- byName: map[string]*models.Agent{},
- profiles: map[string][]*models.AgentProfile{},
- deleted: map[string][]*models.AgentProfile{},
+ agents: map[string]*models.Agent{},
+ byName: map[string]*models.Agent{},
+ profiles: map[string][]*models.AgentProfile{},
+ deleted: map[string][]*models.AgentProfile{},
+ mcpConfigs: map[string]*models.AgentProfileMcpConfig{},
}
}
@@ -97,10 +102,17 @@ func (f *fakeStore) ListTUIAgents(context.Context) ([]*models.Agent, error) {
return nil, nil
}
-func (f *fakeStore) GetAgentProfileMcpConfig(context.Context, string) (*models.AgentProfileMcpConfig, error) {
+// GetAgentProfileMcpConfig implements the settings store interface for the reconciler test fakes.
+func (f *fakeStore) GetAgentProfileMcpConfig(_ context.Context, profileID string) (*models.AgentProfileMcpConfig, error) {
+ if cfg, ok := f.mcpConfigs[profileID]; ok {
+ return cfg, nil
+ }
return nil, nil
}
-func (f *fakeStore) UpsertAgentProfileMcpConfig(context.Context, *models.AgentProfileMcpConfig) error {
+
+// UpsertAgentProfileMcpConfig implements the settings store interface for the reconciler test fakes.
+func (f *fakeStore) UpsertAgentProfileMcpConfig(_ context.Context, config *models.AgentProfileMcpConfig) error {
+ f.mcpConfigs[config.ProfileID] = config
return nil
}
@@ -112,6 +124,50 @@ func (f *fakeStore) CreateAgentProfile(_ context.Context, p *models.AgentProfile
return nil
}
+// DuplicateAgentProfile implements the settings store interface for the reconciler test fakes.
+func (f *fakeStore) DuplicateAgentProfile(_ context.Context, input store.DuplicateAgentProfileInput) error {
+ if f.duplicateProfErr != nil {
+ return f.duplicateProfErr
+ }
+ if f.duplicateChangedOnce {
+ f.duplicateChangedOnce = false
+ // Simulate a concurrent writer: the stored source row changes between
+ // the controller's first read and its duplicate attempt, so a retry
+ // must re-read the source and copy the NEW state.
+ input.Source.Name = "Changed Name"
+ input.Source.UpdatedAt = input.Source.UpdatedAt.Add(time.Second)
+ return store.ErrProfileChanged
+ }
+ // Version check mirrors the sqlite store: the stored source rows must
+ // still match the revisions the copy was built from.
+ if f.profiles[input.Source.AgentID] != nil {
+ for _, p := range f.profiles[input.Source.AgentID] {
+ if p.ID == input.Source.ID && !p.UpdatedAt.Equal(input.Source.UpdatedAt) {
+ return store.ErrProfileChanged
+ }
+ }
+ }
+ if input.SourceMcp != nil {
+ mcp, ok := f.mcpConfigs[input.Source.ID]
+ if !ok || !mcp.UpdatedAt.Equal(input.SourceMcp.UpdatedAt) {
+ return store.ErrProfileChanged
+ }
+ }
+ p := input.Profile
+ f.nextProfID++
+ p.ID = "profile-" + strconv.Itoa(f.nextProfID)
+ now := time.Now().UTC()
+ p.CreatedAt = now
+ p.UpdatedAt = now
+ f.profiles[p.AgentID] = append(f.profiles[p.AgentID], p)
+ f.created = append(f.created, p)
+ if input.McpConfig != nil {
+ input.McpConfig.ProfileID = p.ID
+ f.mcpConfigs[p.ID] = input.McpConfig
+ }
+ return nil
+}
+
func (f *fakeStore) UpdateAgentProfile(_ context.Context, p *models.AgentProfile) error {
f.updated = append(f.updated, p)
return nil
diff --git a/apps/backend/internal/agent/settings/dto/dto.go b/apps/backend/internal/agent/settings/dto/dto.go
index 85106b1195..79671cd469 100644
--- a/apps/backend/internal/agent/settings/dto/dto.go
+++ b/apps/backend/internal/agent/settings/dto/dto.go
@@ -46,6 +46,16 @@ type AgentProfileDTO struct {
UpdatedAt time.Time `json:"updated_at"`
}
+// GetWorkspaceID lets struct-shaped profile payloads (e.g. the MCP event-bus
+// publisher wrapping *AgentProfileDTO under "profile") be routed by the
+// gateway's extractWorkspaceID without a JSON round-trip.
+func (p *AgentProfileDTO) GetWorkspaceID() string {
+ if p == nil {
+ return ""
+ }
+ return p.WorkspaceID
+}
+
// CLIFlagDTO mirrors models.CLIFlag on the wire. Each entry is one user-facing
// CLI argument on a profile; at launch time the `flag` string is shell-split
// and only entries with `enabled:true` reach the agent subprocess argv.
diff --git a/apps/backend/internal/agent/settings/handlers/handlers.go b/apps/backend/internal/agent/settings/handlers/handlers.go
index fbc0b7715a..71b70242e3 100644
--- a/apps/backend/internal/agent/settings/handlers/handlers.go
+++ b/apps/backend/internal/agent/settings/handlers/handlers.go
@@ -75,6 +75,7 @@ func (h *Handlers) registerHTTP(router *gin.Engine) {
api.GET("/agent-update/jobs/:id", h.httpGetAgentUpdateJob)
api.PATCH("/agent-profiles/:id", h.interlock, h.httpUpdateProfile)
api.DELETE("/agent-profiles/:id", h.interlock, h.httpDeleteProfile)
+ api.POST("/agent-profiles/:id/duplicate", h.interlock, h.httpDuplicateProfile)
api.GET("/agent-profiles/:id/mcp-config", h.httpGetProfileMcpConfig)
api.POST("/agent-profiles/:id/mcp-config", h.interlock, h.httpUpdateProfileMcpConfig)
}
@@ -544,12 +545,7 @@ func (h *Handlers) httpCreateProfile(c *gin.Context) {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to create profile"})
return
}
- if h.hub != nil {
- notification, _ := ws.NewNotification(ws.ActionAgentProfileCreated, gin.H{
- "profile": resp,
- })
- h.hub.Broadcast(notification)
- }
+ h.broadcastProfileEvent(ws.ActionAgentProfileCreated, resp)
c.JSON(http.StatusOK, resp)
}
@@ -614,15 +610,62 @@ func (h *Handlers) httpUpdateProfile(c *gin.Context) {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to update profile"})
return
}
- if h.hub != nil {
- notification, _ := ws.NewNotification(ws.ActionAgentProfileUpdated, gin.H{
- "profile": resp,
- })
- h.hub.Broadcast(notification)
- }
+ h.broadcastProfileEvent(ws.ActionAgentProfileUpdated, resp)
c.JSON(http.StatusOK, resp)
}
+// httpDuplicateProfile copies a profile's full configuration into a new row
+// named " copy" and returns the new profile. No request body: the
+// copy name is derived server-side. The existing agent.profile.created
+// notification lets every open settings surface pick the copy up live.
+func (h *Handlers) httpDuplicateProfile(c *gin.Context) {
+ profileID := c.Param("id")
+ if profileID == "" {
+ c.JSON(http.StatusBadRequest, gin.H{"error": "profile id is required"})
+ return
+ }
+ resp, err := h.controller.DuplicateProfile(c.Request.Context(), controller.DuplicateProfileRequest{
+ ID: profileID,
+ })
+ if err != nil {
+ if err == controller.ErrAgentProfileNotFound {
+ c.JSON(http.StatusNotFound, gin.H{"error": "agent profile not found"})
+ return
+ }
+ h.logger.Error("failed to duplicate profile", zap.Error(err))
+ c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to duplicate profile"})
+ return
+ }
+ h.broadcastProfileEvent(ws.ActionAgentProfileCreated, resp)
+ c.JSON(http.StatusOK, resp)
+}
+
+// broadcastProfileEvent fans a profile create/update/delete event out.
+// Kanban profiles (empty WorkspaceID) go to every settings client.
+// Office-scoped profiles are routed through the workspace-scoped broadcaster
+// so their configuration (env vars, servers, ...) never leaks across
+// workspace/user boundaries — the HTTP agent list hides them via
+// filterGlobalProfiles, and the WS path must not contradict that. When the
+// hub does not support workspace routing (test fakes), the office event is
+// dropped fail-closed.
+func (h *Handlers) broadcastProfileEvent(action string, profile *dto.AgentProfileDTO) {
+ if h.hub == nil {
+ return
+ }
+ notification, _ := ws.NewNotification(action, gin.H{
+ "profile": profile,
+ })
+ if profile.WorkspaceID != "" {
+ if workspaceHub, ok := h.hub.(interface {
+ BroadcastToWorkspaceOrDrop(string, *ws.Message)
+ }); ok {
+ workspaceHub.BroadcastToWorkspaceOrDrop(profile.WorkspaceID, notification)
+ }
+ return
+ }
+ h.hub.Broadcast(notification)
+}
+
func (h *Handlers) httpDeleteProfile(c *gin.Context) {
force := c.Query("force") == "true"
profile, err := h.controller.DeleteProfile(c.Request.Context(), c.Param("id"), force)
@@ -647,12 +690,7 @@ func (h *Handlers) httpDeleteProfile(c *gin.Context) {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to delete profile"})
return
}
- if h.hub != nil {
- notification, _ := ws.NewNotification(ws.ActionAgentProfileDeleted, gin.H{
- "profile": profile,
- })
- h.hub.Broadcast(notification)
- }
+ h.broadcastProfileEvent(ws.ActionAgentProfileDeleted, profile)
c.JSON(http.StatusOK, gin.H{"success": true})
}
diff --git a/apps/backend/internal/agent/settings/handlers/interim_settings_interlock_test.go b/apps/backend/internal/agent/settings/handlers/interim_settings_interlock_test.go
index d7e75cca8c..268ec96df7 100644
--- a/apps/backend/internal/agent/settings/handlers/interim_settings_interlock_test.go
+++ b/apps/backend/internal/agent/settings/handlers/interim_settings_interlock_test.go
@@ -52,6 +52,7 @@ func TestRegisterRoutesProtectsEveryStateChangingAgentSettingsRoute(t *testing.T
{method: http.MethodPost, path: "/api/v1/agent-update/agent-1"},
{method: http.MethodPatch, path: "/api/v1/agent-profiles/profile-1"},
{method: http.MethodDelete, path: "/api/v1/agent-profiles/profile-1"},
+ {method: http.MethodPost, path: "/api/v1/agent-profiles/profile-1/duplicate"},
{method: http.MethodPost, path: "/api/v1/agent-profiles/profile-1/mcp-config"},
}
diff --git a/apps/backend/internal/agent/settings/handlers/profile_duplicate_handlers_test.go b/apps/backend/internal/agent/settings/handlers/profile_duplicate_handlers_test.go
new file mode 100644
index 0000000000..cd92831724
--- /dev/null
+++ b/apps/backend/internal/agent/settings/handlers/profile_duplicate_handlers_test.go
@@ -0,0 +1,329 @@
+package handlers
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "sync"
+ "testing"
+ "time"
+
+ "github.com/gin-gonic/gin"
+ "github.com/kandev/kandev/internal/agent/settings/controller"
+ "github.com/kandev/kandev/internal/agent/settings/dto"
+ "github.com/kandev/kandev/internal/agent/settings/models"
+ "github.com/kandev/kandev/internal/agent/settings/store"
+ "github.com/kandev/kandev/internal/common/httpmw"
+ "github.com/kandev/kandev/internal/common/logger"
+ ws "github.com/kandev/kandev/pkg/websocket"
+)
+
+// duplicateRepo is a minimal store.Repository stub: the duplicate path only
+// reads one profile, inserts the copy, flips enabled, and reads/writes the
+// MCP config row. Everything else is a no-op.
+type duplicateRepo struct {
+ profiles map[string]*models.AgentProfile
+ created []*models.AgentProfile
+}
+
+// newDuplicateRepo returns a fake repository preloaded with one kanban profile (p-1) under agent-1.
+func newDuplicateRepo() *duplicateRepo {
+ return &duplicateRepo{profiles: map[string]*models.AgentProfile{}}
+}
+
+// GetAgentProfile implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) GetAgentProfile(_ context.Context, id string) (*models.AgentProfile, error) {
+ if p, ok := r.profiles[id]; ok {
+ return p, nil
+ }
+ return nil, fmt.Errorf("agent profile not found: %s", id)
+}
+
+// GetAgentProfileIncludingDeleted implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) GetAgentProfileIncludingDeleted(ctx context.Context, id string) (*models.AgentProfile, error) {
+ return r.GetAgentProfile(ctx, id)
+}
+
+// CreateAgentProfile implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) CreateAgentProfile(_ context.Context, p *models.AgentProfile) error {
+ if p.ID == "" {
+ p.ID = "duplicate-" + p.Name
+ }
+ r.profiles[p.ID] = p
+ r.created = append(r.created, p)
+ return nil
+}
+
+// DuplicateAgentProfile implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) DuplicateAgentProfile(_ context.Context, input store.DuplicateAgentProfileInput) error {
+ // Version check: the stored source must match the caller's snapshot.
+ if src, ok := r.profiles[input.Source.ID]; ok && !src.UpdatedAt.Equal(input.Source.UpdatedAt) {
+ return store.ErrProfileChanged
+ }
+ p := input.Profile
+ if p.ID == "" {
+ p.ID = "duplicate-" + p.Name
+ }
+ now := time.Now().UTC()
+ p.CreatedAt = now
+ p.UpdatedAt = now
+ r.profiles[p.ID] = p
+ r.created = append(r.created, p)
+ if input.McpConfig != nil {
+ input.McpConfig.ProfileID = p.ID
+ }
+ return nil
+}
+
+// UpdateAgentProfileEnabled implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) UpdateAgentProfileEnabled(_ context.Context, id string, enabled bool) (time.Time, error) {
+ p, ok := r.profiles[id]
+ if !ok {
+ return time.Time{}, fmt.Errorf("agent profile not found: %s", id)
+ }
+ p.Enabled = enabled
+ p.UpdatedAt = time.Now().UTC()
+ return p.UpdatedAt, nil
+}
+
+// GetAgentProfileMcpConfig implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) GetAgentProfileMcpConfig(context.Context, string) (*models.AgentProfileMcpConfig, error) {
+ return nil, nil
+}
+
+// UpsertAgentProfileMcpConfig implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) UpsertAgentProfileMcpConfig(context.Context, *models.AgentProfileMcpConfig) error {
+ return nil
+}
+
+// CreateAgent implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) CreateAgent(context.Context, *models.Agent) error { return nil }
+
+// GetAgent implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) GetAgent(context.Context, string) (*models.Agent, error) {
+ return nil, nil
+}
+
+// GetAgentByName implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) GetAgentByName(context.Context, string) (*models.Agent, error) {
+ return nil, nil
+}
+
+// UpdateAgent implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) UpdateAgent(context.Context, *models.Agent) error { return nil }
+
+// DeleteAgent implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) DeleteAgent(context.Context, string) error { return nil }
+
+// ListAgents implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) ListAgents(context.Context) ([]*models.Agent, error) {
+ return nil, nil
+}
+
+// ListTUIAgents implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) ListTUIAgents(context.Context) ([]*models.Agent, error) {
+ return nil, nil
+}
+
+// UpdateAgentProfile implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) UpdateAgentProfile(context.Context, *models.AgentProfile) error {
+ return nil
+}
+
+// DeleteAgentProfile implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) DeleteAgentProfile(context.Context, string) error { return nil }
+
+// ListAgentProfiles implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) ListAgentProfiles(context.Context, string) ([]*models.AgentProfile, error) {
+ return nil, nil
+}
+
+// HasDeletedAgentProfiles implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) HasDeletedAgentProfiles(context.Context, string) (bool, error) {
+ return false, nil
+}
+
+// Close implements the settings store interface for the duplicate handler tests.
+func (r *duplicateRepo) Close() error { return nil }
+
+var _ store.Repository = (*duplicateRepo)(nil)
+
+// duplicateHub captures every WS message so tests can assert the broadcast.
+type duplicateHub struct {
+ mu sync.Mutex
+ msgs []*ws.Message
+}
+
+// Broadcast records a global notification so tests can assert (non-)delivery.
+func (h *duplicateHub) Broadcast(msg *ws.Message) {
+ h.mu.Lock()
+ defer h.mu.Unlock()
+ h.msgs = append(h.msgs, msg)
+}
+
+// actions returns the global notifications recorded by Broadcast.
+func (h *duplicateHub) actions() []string {
+ h.mu.Lock()
+ defer h.mu.Unlock()
+ out := make([]string, 0, len(h.msgs))
+ for _, m := range h.msgs {
+ out = append(out, m.Action)
+ }
+ return out
+}
+
+// workspaceDuplicateHub models the gateway hub: global Broadcast plus the
+// workspace-scoped, fail-closed BroadcastToWorkspaceOrDrop.
+type workspaceDuplicateHub struct {
+ mu sync.Mutex
+ global []*ws.Message
+ workspaceMsgs map[string][]*ws.Message
+}
+
+// Broadcast records a global notification so tests can assert (non-)delivery.
+func (h *workspaceDuplicateHub) Broadcast(msg *ws.Message) {
+ h.mu.Lock()
+ defer h.mu.Unlock()
+ h.global = append(h.global, msg)
+}
+
+// BroadcastToWorkspaceOrDrop records a workspace-scoped notification so tests can assert (non-)delivery.
+func (h *workspaceDuplicateHub) BroadcastToWorkspaceOrDrop(workspaceID string, msg *ws.Message) {
+ h.mu.Lock()
+ defer h.mu.Unlock()
+ h.workspaceMsgs[workspaceID] = append(h.workspaceMsgs[workspaceID], msg)
+}
+
+// newDuplicateRouter builds a gin router with the settings handlers wired to the given repo and hub.
+func newDuplicateRouter(t *testing.T, repo store.Repository, hub Broadcaster) *gin.Engine {
+ t.Helper()
+ gin.SetMode(gin.TestMode)
+ log, err := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json"})
+ if err != nil {
+ t.Fatalf("NewLogger: %v", err)
+ }
+ ctrl := controller.NewController(repo, nil, nil, nil, log)
+ router := gin.New()
+ NewHandlers(ctrl, hub, log, "test-interlock").registerHTTP(router)
+ return router
+}
+
+// TestDuplicateProfileEndpoint_CopiesAndBroadcasts verifies the HTTP endpoint copies a kanban profile and broadcasts agent.profile.created.
+func TestDuplicateProfileEndpoint_CopiesAndBroadcasts(t *testing.T) {
+ repo := newDuplicateRepo()
+ repo.profiles["source-1"] = &models.AgentProfile{
+ ID: "source-1",
+ AgentID: "agent-1",
+ Name: "Default",
+ AgentDisplayName: "Claude Code",
+ Model: "claude-sonnet",
+ CLIFlags: []models.CLIFlag{{Description: "Tools", Flag: "--allow-all-tools", Enabled: true}},
+ Enabled: true,
+ }
+ hub := &duplicateHub{}
+ router := newDuplicateRouter(t, repo, hub)
+
+ req := httptest.NewRequest(http.MethodPost, "/api/v1/agent-profiles/source-1/duplicate", nil)
+ req.Header.Set(httpmw.InterimSettingsInterlockHeader, "test-interlock")
+ rec := httptest.NewRecorder()
+ router.ServeHTTP(rec, req)
+
+ if rec.Code != http.StatusOK {
+ t.Fatalf("status = %d, want 200; body: %s", rec.Code, rec.Body.String())
+ }
+ var created dto.AgentProfileDTO
+ if err := json.Unmarshal(rec.Body.Bytes(), &created); err != nil {
+ t.Fatalf("decode response: %v", err)
+ }
+ if created.ID == "source-1" || created.ID == "" {
+ t.Errorf("response profile ID = %q, want a fresh ID", created.ID)
+ }
+ if created.Name != "Default Copy" {
+ t.Errorf("response name = %q, want %q", created.Name, "Default Copy")
+ }
+ if created.Model != "claude-sonnet" {
+ t.Errorf("response model = %q, want claude-sonnet", created.Model)
+ }
+ if len(created.CLIFlags) != 1 || created.CLIFlags[0].Flag != "--allow-all-tools" {
+ t.Errorf("response cli flags = %+v, want the source entry", created.CLIFlags)
+ }
+
+ found := false
+ for _, action := range hub.actions() {
+ if action == ws.ActionAgentProfileCreated {
+ found = true
+ }
+ }
+ if !found {
+ t.Errorf("no %s broadcast, got %v", ws.ActionAgentProfileCreated, hub.actions())
+ }
+ if len(repo.created) != 1 {
+ t.Fatalf("stored copies = %d, want 1", len(repo.created))
+ }
+}
+
+// TestDuplicateProfileEndpoint_NotFound verifies an unknown source ID surfaces as HTTP 404.
+func TestDuplicateProfileEndpoint_NotFound(t *testing.T) {
+ router := newDuplicateRouter(t, newDuplicateRepo(), nil)
+
+ req := httptest.NewRequest(http.MethodPost, "/api/v1/agent-profiles/missing/duplicate", nil)
+ req.Header.Set(httpmw.InterimSettingsInterlockHeader, "test-interlock")
+ rec := httptest.NewRecorder()
+ router.ServeHTTP(rec, req)
+
+ if rec.Code != http.StatusNotFound {
+ t.Fatalf("status = %d, want 404; body: %s", rec.Code, rec.Body.String())
+ }
+ if !strings.Contains(rec.Body.String(), "agent profile not found") {
+ t.Errorf("body = %q, want agent profile not found message", rec.Body.String())
+ }
+}
+
+// TestDuplicateProfileEndpoint_RejectsOfficeScopedSource verifies the
+// settings duplicate endpoint refuses office-scoped profiles fail-closed:
+// the source is owned by the workspace-scoped office surface, so the request
+// surfaces as 404 (existence hidden) and no event is broadcast on any channel
+// (workspace-aware or global).
+func TestDuplicateProfileEndpoint_RejectsOfficeScopedSource(t *testing.T) {
+ repo := newDuplicateRepo()
+ repo.profiles["source-office"] = &models.AgentProfile{
+ ID: "source-office",
+ AgentID: "agent-1",
+ Name: "Office Agent",
+ WorkspaceID: "ws-1",
+ Enabled: true,
+ }
+ hub := &workspaceDuplicateHub{workspaceMsgs: map[string][]*ws.Message{}}
+ router := newDuplicateRouter(t, repo, hub)
+
+ req := httptest.NewRequest(http.MethodPost, "/api/v1/agent-profiles/source-office/duplicate", nil)
+ req.Header.Set(httpmw.InterimSettingsInterlockHeader, "test-interlock")
+ rec := httptest.NewRecorder()
+ router.ServeHTTP(rec, req)
+
+ if rec.Code != http.StatusNotFound {
+ t.Fatalf("status = %d, want 404; body: %s", rec.Code, rec.Body.String())
+ }
+ if len(hub.global) != 0 {
+ t.Errorf("office duplicate leaked to the global settings broadcast: %d messages", len(hub.global))
+ }
+ if len(hub.workspaceMsgs) != 0 {
+ t.Errorf("office duplicate broadcast workspace-scoped messages: %v", hub.workspaceMsgs)
+ }
+}
+
+// TestDuplicateProfileEndpoint_RequiresInterlock verifies the duplicate route is rejected without the interlock token.
+func TestDuplicateProfileEndpoint_RequiresInterlock(t *testing.T) {
+ router := newDuplicateRouter(t, newDuplicateRepo(), nil)
+
+ req := httptest.NewRequest(http.MethodPost, "/api/v1/agent-profiles/source-1/duplicate", nil)
+ rec := httptest.NewRecorder()
+ router.ServeHTTP(rec, req)
+
+ if rec.Code != http.StatusForbidden {
+ t.Fatalf("status = %d, want 403 without interlock token", rec.Code)
+ }
+}
diff --git a/apps/backend/internal/agent/settings/store/sqlite.go b/apps/backend/internal/agent/settings/store/sqlite.go
index b50f6c4561..cdee34d97c 100644
--- a/apps/backend/internal/agent/settings/store/sqlite.go
+++ b/apps/backend/internal/agent/settings/store/sqlite.go
@@ -450,6 +450,14 @@ func (r *sqliteRepository) UpsertAgentProfileMcpConfig(ctx context.Context, conf
if config.ProfileID == "" {
return fmt.Errorf("profile ID is required")
}
+ return r.upsertAgentProfileMcpConfig(ctx, r.db, config)
+}
+
+// upsertAgentProfileMcpConfig inserts or replaces the MCP config row for a
+// profile, running against the caller-supplied execer so the duplicate can
+// commit it in the same transaction as the profile row. Defaults nil maps and
+// fills timestamps on the passed config in place.
+func (r *sqliteRepository) upsertAgentProfileMcpConfig(ctx context.Context, execer profileExecer, config *models.AgentProfileMcpConfig) error {
if config.Servers == nil {
config.Servers = map[string]interface{}{}
}
@@ -471,7 +479,7 @@ func (r *sqliteRepository) UpsertAgentProfileMcpConfig(ctx context.Context, conf
return fmt.Errorf("failed to serialize MCP meta: %w", err)
}
- _, err = r.db.ExecContext(ctx, r.db.Rebind(`
+ _, err = execer.ExecContext(ctx, execer.Rebind(`
INSERT INTO agent_profile_mcp_configs (profile_id, enabled, servers_json, meta_json, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?)
ON CONFLICT(profile_id) DO UPDATE SET
@@ -490,6 +498,116 @@ func (r *sqliteRepository) CreateAgentProfile(ctx context.Context, profile *mode
now := time.Now().UTC()
profile.CreatedAt = now
profile.UpdatedAt = now
+ // New profiles are created enabled — the DB column default is 1 and
+ // nothing creates a profile pre-disabled. Setting the field here keeps
+ // callers' in-memory copy consistent with the row.
+ profile.Enabled = true
+ return r.insertAgentProfile(ctx, r.db, profile)
+}
+
+// DuplicateAgentProfile creates an independent copy of a profile in a single
+// transaction: the row is inserted with the caller-provided Enabled state (a
+// duplicate of a disabled profile must not become briefly selectable) and the
+// MCP config row is upserted when non-nil. A failure rolls back and leaves no
+// partial copy, so retrying after an error cannot create a duplicate row.
+//
+// The source rows are re-read inside the transaction and must still carry the
+// revisions the copy was built from; otherwise ErrProfileChanged is returned
+// and nothing is created. Combined with WAL snapshot isolation (a concurrent
+// commit after this transaction's first read aborts its write with a busy
+// error), the copy always reflects one consistent snapshot of the source.
+func (r *sqliteRepository) DuplicateAgentProfile(ctx context.Context, input DuplicateAgentProfileInput) error {
+ if input.Profile.ID == "" {
+ input.Profile.ID = uuid.New().String()
+ }
+ tx, err := r.db.BeginTxx(ctx, nil)
+ if err != nil {
+ return err
+ }
+ defer func() { _ = tx.Rollback() }()
+
+ if err := r.verifySourceSnapshot(ctx, tx, input); err != nil {
+ return err
+ }
+
+ now := time.Now().UTC()
+ input.Profile.CreatedAt = now
+ input.Profile.UpdatedAt = now
+ if err := r.insertAgentProfile(ctx, tx, input.Profile); err != nil {
+ return err
+ }
+ if input.McpConfig != nil {
+ input.McpConfig.ProfileID = input.Profile.ID
+ if err := r.upsertAgentProfileMcpConfig(ctx, tx, input.McpConfig); err != nil {
+ return err
+ }
+ }
+ return tx.Commit()
+}
+
+// verifySourceSnapshot checks, inside the duplicate transaction, that the
+// source rows still match the revisions the caller built the copy from. A
+// mismatch means a concurrent writer changed the source between the caller's
+// read and this transaction — duplicating anyway would produce a copy mixing
+// two points in time.
+func (r *sqliteRepository) verifySourceSnapshot(ctx context.Context, tx *sqlx.Tx, input DuplicateAgentProfileInput) error {
+ var sourceUpdated time.Time
+ err := tx.QueryRowContext(ctx, tx.Rebind(
+ `SELECT updated_at FROM agent_profiles WHERE id = ? AND deleted_at IS NULL`),
+ input.Source.ID).Scan(&sourceUpdated)
+ if errors.Is(err, sql.ErrNoRows) {
+ return ErrSourceProfileNotFound
+ }
+ if err != nil {
+ return err
+ }
+ if !sourceUpdated.Equal(input.Source.UpdatedAt) {
+ return ErrProfileChanged
+ }
+ if input.SourceMcp == nil {
+ // The caller's snapshot had no MCP row: verify one was not created in
+ // the meantime, otherwise the copy would silently drop it. Missing is
+ // the unchanged case; an existing row means the snapshot is stale.
+ var exists int
+ err = tx.QueryRowContext(ctx, tx.Rebind(
+ `SELECT 1 FROM agent_profile_mcp_configs WHERE profile_id = ?`),
+ input.Source.ID).Scan(&exists)
+ if err == nil {
+ return ErrProfileChanged
+ }
+ if !errors.Is(err, sql.ErrNoRows) {
+ return err
+ }
+ return nil
+ }
+ var mcpUpdated time.Time
+ err = tx.QueryRowContext(ctx, tx.Rebind(
+ `SELECT updated_at FROM agent_profile_mcp_configs WHERE profile_id = ?`),
+ input.Source.ID).Scan(&mcpUpdated)
+ if errors.Is(err, sql.ErrNoRows) {
+ return ErrProfileChanged
+ }
+ if err != nil {
+ return err
+ }
+ if !mcpUpdated.Equal(input.SourceMcp.UpdatedAt) {
+ return ErrProfileChanged
+ }
+ return nil
+}
+
+// profileExecer is the subset of *sqlx.DB / *sqlx.Tx the shared insert and
+// upsert helpers need, so one code path serves both single-statement and
+// transactional writes.
+type profileExecer interface {
+ ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
+ Rebind(query string) string
+}
+
+// insertAgentProfile writes the profile row through the caller-supplied
+// execer, sharing one SQL statement between CreateAgentProfile and the
+// transactional duplicate path. The profile's Enabled value is written as-is.
+func (r *sqliteRepository) insertAgentProfile(ctx context.Context, execer profileExecer, profile *models.AgentProfile) error {
cliFlagsJSON, err := cliFlagsToJSON(profile.CLIFlags)
if err != nil {
return err
@@ -502,11 +620,7 @@ func (r *sqliteRepository) CreateAgentProfile(ctx context.Context, profile *mode
if err != nil {
return err
}
- // New profiles are created enabled — the DB column default is 1 and
- // nothing creates a profile pre-disabled. Setting the field here keeps
- // callers' in-memory copy consistent with the row.
- profile.Enabled = true
- _, err = r.db.ExecContext(ctx, r.db.Rebind(`
+ _, err = execer.ExecContext(ctx, execer.Rebind(`
INSERT INTO agent_profiles (
id, agent_id, name, agent_display_name, model, mode, migrated_from,
auto_approve, dangerously_skip_permissions, allow_indexing, cli_passthrough,
diff --git a/apps/backend/internal/agent/settings/store/sqlite_duplicate_test.go b/apps/backend/internal/agent/settings/store/sqlite_duplicate_test.go
new file mode 100644
index 0000000000..d393f33578
--- /dev/null
+++ b/apps/backend/internal/agent/settings/store/sqlite_duplicate_test.go
@@ -0,0 +1,291 @@
+package store
+
+import (
+ "context"
+ "database/sql"
+ "errors"
+ "testing"
+
+ "github.com/kandev/kandev/internal/agent/settings/models"
+)
+
+// TestDuplicateAgentProfile_RoundTrip verifies the atomic copy path: the copy
+// gets a fresh ID, keeps every configuration field, preserves the source's
+// disabled state (the store must NOT force a duplicate enabled like
+// CreateAgentProfile does), and copies the MCP config row in the same write.
+func TestDuplicateAgentProfile_RoundTrip(t *testing.T) {
+ repo := newFreshRepo(t)
+ ctx := context.Background()
+
+ if err := repo.CreateAgent(ctx, &models.Agent{Name: "test-agent", SupportsMCP: true}); err != nil {
+ t.Fatalf("seed agent: %v", err)
+ }
+ agent, err := repo.GetAgentByName(ctx, "test-agent")
+ if err != nil {
+ t.Fatalf("get agent: %v", err)
+ }
+
+ source := &models.AgentProfile{
+ AgentID: agent.ID,
+ Name: "Default",
+ AgentDisplayName: "Test Agent",
+ Model: "model-1",
+ Mode: "plan",
+ AutoApprove: true,
+ CLIPassthrough: true,
+ CLIFlags: []models.CLIFlag{{Description: "Tools", Flag: "--allow-all-tools", Enabled: true}},
+ EnvVars: []models.ProfileEnvVar{{Key: "FOO", Value: "bar"}},
+ CommandPrefix: "greywall --",
+ UserModified: true,
+ }
+ if err := repo.CreateAgentProfile(ctx, source); err != nil {
+ t.Fatalf("create source: %v", err)
+ }
+ // CreateAgentProfile forces enabled=true; simulate a user-disabled source.
+ // The returned timestamp is the DB revision the duplicate input must carry.
+ disabledAt, err := repo.UpdateAgentProfileEnabled(ctx, source.ID, false)
+ if err != nil {
+ t.Fatalf("disable source: %v", err)
+ }
+ source.UpdatedAt = disabledAt
+ sourceMcp := &models.AgentProfileMcpConfig{
+ ProfileID: source.ID,
+ Enabled: true,
+ Servers: map[string]interface{}{"github": map[string]interface{}{"url": "https://api.github.com"}},
+ Meta: map[string]interface{}{"k": "v"},
+ }
+ if err := repo.UpsertAgentProfileMcpConfig(ctx, sourceMcp); err != nil {
+ t.Fatalf("seed source mcp: %v", err)
+ }
+
+ clone := &models.AgentProfile{
+ AgentID: source.AgentID,
+ Name: "Default Copy",
+ AgentDisplayName: source.AgentDisplayName,
+ Model: source.Model,
+ Mode: source.Mode,
+ AutoApprove: source.AutoApprove,
+ CLIPassthrough: source.CLIPassthrough,
+ CLIFlags: source.CLIFlags,
+ EnvVars: source.EnvVars,
+ CommandPrefix: source.CommandPrefix,
+ Enabled: false,
+ UserModified: true,
+ }
+ copiedMcp := &models.AgentProfileMcpConfig{
+ Enabled: sourceMcp.Enabled,
+ Servers: sourceMcp.Servers,
+ Meta: sourceMcp.Meta,
+ }
+ if err := repo.DuplicateAgentProfile(ctx, DuplicateAgentProfileInput{
+ Source: source,
+ SourceMcp: sourceMcp,
+ Profile: clone,
+ McpConfig: copiedMcp,
+ }); err != nil {
+ t.Fatalf("DuplicateAgentProfile: %v", err)
+ }
+
+ if clone.ID == source.ID || clone.ID == "" {
+ t.Fatalf("copy ID = %q, want a fresh ID", clone.ID)
+ }
+ got, err := repo.GetAgentProfile(ctx, clone.ID)
+ if err != nil {
+ t.Fatalf("get copy: %v", err)
+ }
+ // The duplicate must NOT be forced enabled like CreateAgentProfile: a
+ // disabled source produces a disabled copy in the same write.
+ if got.Enabled {
+ t.Error("duplicate enabled = true, want false (source disabled)")
+ }
+ if got.Name != "Default Copy" || got.Model != "model-1" || got.Mode != "plan" ||
+ !got.AutoApprove || !got.CLIPassthrough || got.CommandPrefix != "greywall --" ||
+ len(got.CLIFlags) != 1 || got.CLIFlags[0].Flag != "--allow-all-tools" ||
+ len(got.EnvVars) != 1 || got.EnvVars[0].Key != "FOO" {
+ t.Errorf("copy configuration not preserved: %+v", got)
+ }
+ if !got.CreatedAt.Equal(got.UpdatedAt) {
+ t.Errorf("copy timestamps differ: created=%v updated=%v", got.CreatedAt, got.UpdatedAt)
+ }
+
+ gotMcp, err := repo.GetAgentProfileMcpConfig(ctx, clone.ID)
+ if err != nil {
+ t.Fatalf("get copy mcp config: %v", err)
+ }
+ if gotMcp == nil || !gotMcp.Enabled {
+ t.Fatal("copy mcp config missing or disabled")
+ }
+ servers, ok := gotMcp.Servers["github"].(map[string]interface{})
+ if !ok || servers["url"] != "https://api.github.com" {
+ t.Errorf("copy mcp servers = %+v, want github entry preserved", gotMcp.Servers)
+ }
+ if gotMcp.Meta["k"] != "v" {
+ t.Errorf("copy mcp meta = %+v, want k=v", gotMcp.Meta)
+ }
+
+ // The source row must be untouched.
+ srcAgain, err := repo.GetAgentProfile(ctx, source.ID)
+ if err != nil || srcAgain == nil || srcAgain.Enabled {
+ t.Errorf("source row altered by duplicate: err=%v enabled=%v", err, srcAgain.Enabled)
+ }
+}
+
+// TestDuplicateAgentProfile_NoMcpConfig verifies the copy is created without
+// an MCP row when none is passed.
+func TestDuplicateAgentProfile_NoMcpConfig(t *testing.T) {
+ repo := newFreshRepo(t)
+ ctx := context.Background()
+
+ if err := repo.CreateAgent(ctx, &models.Agent{Name: "test-agent"}); err != nil {
+ t.Fatalf("seed agent: %v", err)
+ }
+ agent, err := repo.GetAgentByName(ctx, "test-agent")
+ if err != nil {
+ t.Fatalf("get agent: %v", err)
+ }
+ source := &models.AgentProfile{AgentID: agent.ID, Name: "Default"}
+ if err := repo.CreateAgentProfile(ctx, source); err != nil {
+ t.Fatalf("create source: %v", err)
+ }
+
+ clone := &models.AgentProfile{AgentID: agent.ID, Name: "Default Copy"}
+ if err := repo.DuplicateAgentProfile(ctx, DuplicateAgentProfileInput{
+ Source: source,
+ Profile: clone,
+ }); err != nil {
+ t.Fatalf("DuplicateAgentProfile: %v", err)
+ }
+ if _, err := repo.GetAgentProfileMcpConfig(ctx, clone.ID); err == nil {
+ t.Fatal("expected no MCP row for a copy without config")
+ }
+}
+
+// TestDuplicateAgentProfile_DetectsConcurrentChange verifies the transaction
+// aborts with ErrProfileChanged when the source row moved on since the caller
+// built the copy (here: a stale revision), and creates nothing.
+func TestDuplicateAgentProfile_DetectsConcurrentChange(t *testing.T) {
+ repo := newFreshRepo(t)
+ ctx := context.Background()
+
+ if err := repo.CreateAgent(ctx, &models.Agent{Name: "test-agent"}); err != nil {
+ t.Fatalf("seed agent: %v", err)
+ }
+ agent, err := repo.GetAgentByName(ctx, "test-agent")
+ if err != nil {
+ t.Fatalf("get agent: %v", err)
+ }
+ source := &models.AgentProfile{AgentID: agent.ID, Name: "Default"}
+ if err := repo.CreateAgentProfile(ctx, source); err != nil {
+ t.Fatalf("create source: %v", err)
+ }
+ // A concurrent writer bumps the source after the caller's snapshot.
+ if _, err := repo.UpdateAgentProfileEnabled(ctx, source.ID, false); err != nil {
+ t.Fatalf("bump source: %v", err)
+ }
+
+ clone := &models.AgentProfile{AgentID: agent.ID, Name: "Default Copy"}
+ err = repo.DuplicateAgentProfile(ctx, DuplicateAgentProfileInput{
+ Source: source, // stale: UpdatedAt predates the bump above
+ Profile: clone,
+ })
+ if !errors.Is(err, ErrProfileChanged) {
+ t.Fatalf("err = %v, want ErrProfileChanged", err)
+ }
+ if _, err := repo.GetAgentProfile(ctx, clone.ID); !errors.Is(err, sql.ErrNoRows) {
+ t.Fatalf("copy row created despite stale source: err=%v", err)
+ }
+}
+
+// TestDuplicateAgentProfile_DetectsMcpRowCreatedMidFlight verifies the
+// transaction aborts when the caller's snapshot had NO MCP row but one was
+// created before the duplicate ran — otherwise the copy would silently drop
+// the newly configured servers.
+func TestDuplicateAgentProfile_DetectsMcpRowCreatedMidFlight(t *testing.T) {
+ repo := newFreshRepo(t)
+ ctx := context.Background()
+
+ if err := repo.CreateAgent(ctx, &models.Agent{Name: "test-agent"}); err != nil {
+ t.Fatalf("seed agent: %v", err)
+ }
+ agent, err := repo.GetAgentByName(ctx, "test-agent")
+ if err != nil {
+ t.Fatalf("get agent: %v", err)
+ }
+ source := &models.AgentProfile{AgentID: agent.ID, Name: "Default"}
+ if err := repo.CreateAgentProfile(ctx, source); err != nil {
+ t.Fatalf("create source: %v", err)
+ }
+ // The caller read "no MCP row", then a concurrent writer created one.
+ mcp := &models.AgentProfileMcpConfig{
+ ProfileID: source.ID,
+ Enabled: true,
+ Servers: map[string]interface{}{"github": "x"},
+ }
+ if err := repo.UpsertAgentProfileMcpConfig(ctx, mcp); err != nil {
+ t.Fatalf("create source mcp: %v", err)
+ }
+
+ clone := &models.AgentProfile{AgentID: agent.ID, Name: "Default Copy"}
+ err = repo.DuplicateAgentProfile(ctx, DuplicateAgentProfileInput{
+ Source: source, // SourceMcp nil: snapshot predates the MCP row
+ Profile: clone,
+ })
+ if !errors.Is(err, ErrProfileChanged) {
+ t.Fatalf("err = %v, want ErrProfileChanged (MCP row created mid-flight)", err)
+ }
+ if _, err := repo.GetAgentProfile(ctx, clone.ID); !errors.Is(err, sql.ErrNoRows) {
+ t.Fatalf("copy row created despite new MCP row: err=%v", err)
+ }
+}
+
+// TestDuplicateAgentProfile_RollsBackMcpFailure verifies the transaction
+// rolls back the inserted profile row when the MCP upsert fails AFTER the
+// insert. A regression that commits the profile before the MCP write would
+// leave a partial, selectable copy on every failed duplicate.
+func TestDuplicateAgentProfile_RollsBackMcpFailure(t *testing.T) {
+ repo := newFreshRepo(t)
+ ctx := context.Background()
+
+ if err := repo.CreateAgent(ctx, &models.Agent{Name: "test-agent"}); err != nil {
+ t.Fatalf("seed agent: %v", err)
+ }
+ agent, err := repo.GetAgentByName(ctx, "test-agent")
+ if err != nil {
+ t.Fatalf("get agent: %v", err)
+ }
+ source := &models.AgentProfile{AgentID: agent.ID, Name: "Default"}
+ if err := repo.CreateAgentProfile(ctx, source); err != nil {
+ t.Fatalf("create source: %v", err)
+ }
+ // The source has a valid MCP row so the snapshot verification passes and
+ // the failure below happens during the insert-time serialization.
+ sourceMcp := &models.AgentProfileMcpConfig{
+ ProfileID: source.ID,
+ Enabled: true,
+ Servers: map[string]interface{}{"ok": "v"},
+ }
+ if err := repo.UpsertAgentProfileMcpConfig(ctx, sourceMcp); err != nil {
+ t.Fatalf("seed source mcp: %v", err)
+ }
+
+ clone := &models.AgentProfile{AgentID: agent.ID, Name: "Default Copy"}
+ // A channel is not JSON-serializable: the MCP upsert fails during
+ // serialization, which happens AFTER the profile row was inserted inside
+ // the transaction.
+ badMcp := &models.AgentProfileMcpConfig{
+ Enabled: true,
+ Servers: map[string]interface{}{"bad": make(chan int)},
+ }
+ err = repo.DuplicateAgentProfile(ctx, DuplicateAgentProfileInput{
+ Source: source,
+ SourceMcp: sourceMcp,
+ Profile: clone,
+ McpConfig: badMcp,
+ })
+ if err == nil {
+ t.Fatal("expected MCP serialization error, got nil")
+ }
+ if _, err := repo.GetAgentProfile(ctx, clone.ID); !errors.Is(err, sql.ErrNoRows) {
+ t.Fatalf("copy row survived a failed duplicate (rollback missing): err=%v", err)
+ }
+}
diff --git a/apps/backend/internal/agent/settings/store/store.go b/apps/backend/internal/agent/settings/store/store.go
index 2114b291f8..4a1f78c5a5 100644
--- a/apps/backend/internal/agent/settings/store/store.go
+++ b/apps/backend/internal/agent/settings/store/store.go
@@ -2,11 +2,34 @@ package store
import (
"context"
+ "errors"
"time"
"github.com/kandev/kandev/internal/agent/settings/models"
)
+var (
+ // ErrProfileChanged is returned by DuplicateAgentProfile when a source
+ // row changed between the caller's read and the transactional insert, so
+ // the copy would not reflect a consistent snapshot. Callers retry on a
+ // fresh read.
+ ErrProfileChanged = errors.New("source profile changed during duplicate")
+ // ErrSourceProfileNotFound is returned by DuplicateAgentProfile when the
+ // source profile row no longer exists (deleted mid-flight).
+ ErrSourceProfileNotFound = errors.New("source profile not found")
+)
+
+// DuplicateAgentProfileInput carries everything the atomic duplicate needs:
+// the copy rows the caller built (Profile, McpConfig) plus the source rows
+// they were built from (Source, SourceMcp) so the transaction can verify the
+// copy reflects one consistent snapshot.
+type DuplicateAgentProfileInput struct {
+ Source *models.AgentProfile
+ SourceMcp *models.AgentProfileMcpConfig // nil when the source has no MCP row
+ Profile *models.AgentProfile
+ McpConfig *models.AgentProfileMcpConfig // nil when SourceMcp is nil
+}
+
type Repository interface {
CreateAgent(ctx context.Context, agent *models.Agent) error
GetAgent(ctx context.Context, id string) (*models.Agent, error)
@@ -20,6 +43,13 @@ type Repository interface {
UpsertAgentProfileMcpConfig(ctx context.Context, config *models.AgentProfileMcpConfig) error
CreateAgentProfile(ctx context.Context, profile *models.AgentProfile) error
+ // DuplicateAgentProfile creates an independent copy of a profile in one
+ // transaction: the row is inserted with the caller-provided Enabled state
+ // and the MCP config row is upserted when non-nil. A failure rolls back
+ // and leaves no partial copy. The source rows are re-read inside the
+ // transaction and must still match the revisions the copy was built from;
+ // otherwise ErrProfileChanged is returned and no row is created.
+ DuplicateAgentProfile(ctx context.Context, input DuplicateAgentProfileInput) error
UpdateAgentProfile(ctx context.Context, profile *models.AgentProfile) error
UpdateAgentProfileEnabled(ctx context.Context, id string, enabled bool) (time.Time, error)
DeleteAgentProfile(ctx context.Context, id string) error
diff --git a/apps/backend/internal/gateway/websocket/access_test.go b/apps/backend/internal/gateway/websocket/access_test.go
index d277b209c6..cb805eea17 100644
--- a/apps/backend/internal/gateway/websocket/access_test.go
+++ b/apps/backend/internal/gateway/websocket/access_test.go
@@ -11,6 +11,7 @@ import (
"github.com/gin-gonic/gin"
+ "github.com/kandev/kandev/internal/agent/settings/dto"
"github.com/kandev/kandev/internal/auth/authn"
"github.com/kandev/kandev/internal/common/logger"
ws "github.com/kandev/kandev/pkg/websocket"
@@ -328,6 +329,54 @@ func TestBroadcastToWorkspaceRoutesByOwner(t *testing.T) {
waitForMessage(t, clientA)
}
+// TestBroadcastToWorkspaceOrDropFailsClosed verifies office-scoped broadcasts
+// are dropped when the hub cannot route by workspace.
+func TestBroadcastToWorkspaceOrDropFailsClosed(t *testing.T) {
+ hub := newAccessTestHub(t)
+ hub.setAuthPolicy(AuthPolicy{
+ Enforced: func() bool { return true },
+ WorkspaceOwner: func(_ context.Context, workspaceID string) (string, error) {
+ if workspaceID == "ws-a" {
+ return "user-a", nil
+ }
+ return "", errors.New("unknown workspace")
+ },
+ })
+ clientA := registerAccessClient(t, hub, "a", authn.Identity{UserID: "user-a", Role: authn.RoleMember})
+ clientB := registerAccessClient(t, hub, "b", authn.Identity{UserID: "user-b", Role: authn.RoleMember})
+
+ notify := func(action string) *ws.Message {
+ msg, err := ws.NewNotification(action, map[string]interface{}{"workspace_id": "ws-a"})
+ if err != nil {
+ t.Fatal(err)
+ }
+ return msg
+ }
+
+ // Resolvable workspace: only the owner receives it, the foreign user
+ // never does.
+ hub.BroadcastToWorkspaceOrDrop("ws-a", notify("agent.profile.updated"))
+ if got := receivedActions(clientA); len(got) != 1 {
+ t.Fatalf("owner received %v, want 1 message", got)
+ }
+ if got := receivedActions(clientB); len(got) != 0 {
+ t.Fatalf("foreign user received %v, want none — WS LEAK", got)
+ }
+
+ // Unresolvable workspace: DROPPED under enforced auth — never the
+ // global fallback that BroadcastToWorkspace applies.
+ hub.BroadcastToWorkspaceOrDrop("ws-mystery", notify("agent.profile.updated"))
+ if got := receivedActions(clientB); len(got) != 0 {
+ t.Fatalf("unresolvable workspace leaked globally: %v", got)
+ }
+
+ // Empty workspace ID under enforced auth: DROPPED.
+ hub.BroadcastToWorkspaceOrDrop("", notify("agent.profile.updated"))
+ if got := receivedActions(clientB); len(got) != 0 {
+ t.Fatalf("empty workspace leaked globally: %v", got)
+ }
+}
+
func waitForMessage(t *testing.T, client *Client) {
t.Helper()
select {
@@ -467,4 +516,18 @@ func TestExtractWorkspaceIDFieldShapes(t *testing.T) {
if got := extractWorkspaceID("not-a-map"); got != "" {
t.Fatalf("non-map payload: %q", got)
}
+ // Profile events wrap the profile under "profile". The wrapper is a map
+ // after a JSON round-trip (remote event bus) and a struct on the
+ // in-process bus; both must resolve the nested workspace ID so office
+ // profile events never fall back to the global broadcast.
+ if got := extractWorkspaceID(map[string]interface{}{
+ "profile": map[string]interface{}{"workspace_id": "ws-nested-map"},
+ }); got != "ws-nested-map" {
+ t.Fatalf("map-nested profile workspace_id: %q", got)
+ }
+ if got := extractWorkspaceID(map[string]interface{}{
+ "profile": &dto.AgentProfileDTO{WorkspaceID: "ws-nested-struct"},
+ }); got != "ws-nested-struct" {
+ t.Fatalf("struct-nested profile workspace_id: %q", got)
+ }
}
diff --git a/apps/backend/internal/gateway/websocket/hub.go b/apps/backend/internal/gateway/websocket/hub.go
index 53d062d700..8288dadbcf 100644
--- a/apps/backend/internal/gateway/websocket/hub.go
+++ b/apps/backend/internal/gateway/websocket/hub.go
@@ -317,6 +317,39 @@ func (h *Hub) BroadcastToWorkspace(workspaceID string, msg *ws.Message) {
h.Broadcast(msg)
return
}
+ h.broadcastToOwner(owner, msg)
+}
+
+// BroadcastToWorkspaceOrDrop is the fail-closed sibling of
+// BroadcastToWorkspace: when per-user auth is enforced it DROPS the message
+// unless the workspace is non-empty AND resolves to a known owner — it never
+// falls back to a global broadcast. Every Office notification is
+// workspace-scoped, so an office payload whose workspace could not be
+// resolved must never cross user boundaries. With auth disabled (single
+// user) it degrades to a plain global broadcast, preserving today's
+// behavior.
+func (h *Hub) BroadcastToWorkspaceOrDrop(workspaceID string, msg *ws.Message) {
+ if !h.workspaceScopeEnforced() {
+ h.BroadcastToWorkspace(workspaceID, msg)
+ return
+ }
+ if workspaceID == "" {
+ return // fail closed: no unattributed office fan-out under auth
+ }
+ resolver := h.authPolicy.WorkspaceOwner
+ if resolver == nil {
+ return // fail closed: cannot scope without an owner resolver
+ }
+ owner, err := resolver(h.DispatchContext(), workspaceID)
+ if err != nil || owner == "" {
+ return // fail closed: unresolvable workspace must not go global
+ }
+ h.broadcastToOwner(owner, msg)
+}
+
+// broadcastToOwner fans a message out to the clients allowed to see the
+// workspace owner. Shared by the workspace-scoped broadcast paths.
+func (h *Hub) broadcastToOwner(owner string, msg *ws.Message) {
data, err := json.Marshal(msg)
if err != nil {
h.logger.Error("Failed to marshal workspace broadcast", zap.Error(err))
@@ -333,19 +366,6 @@ func (h *Hub) BroadcastToWorkspace(workspaceID string, msg *ws.Message) {
h.sendToClients(data, recipients, msg.Action)
}
-// BroadcastToWorkspaceOrDrop routes like BroadcastToWorkspace but, when auth is
-// enforced and the workspace is unknown, DROPS the message instead of falling
-// back to a global broadcast. Every Office notification is workspace-scoped, so
-// an office payload whose workspace could not be resolved must never cross user
-// boundaries. With auth disabled (single user) it degrades to a plain global
-// broadcast, preserving today's behavior.
-func (h *Hub) BroadcastToWorkspaceOrDrop(workspaceID string, msg *ws.Message) {
- if workspaceID == "" && h.workspaceScopeEnforced() {
- return // fail closed: no unattributed office fan-out under auth
- }
- h.BroadcastToWorkspace(workspaceID, msg)
-}
-
// workspaceScopeEnforced reports whether per-user auth is currently on.
func (h *Hub) workspaceScopeEnforced() bool {
enforced := h.authPolicy.Enforced
diff --git a/apps/backend/internal/gateway/websocket/task_notifications.go b/apps/backend/internal/gateway/websocket/task_notifications.go
index 2d67bac2cb..0a6937b41c 100644
--- a/apps/backend/internal/gateway/websocket/task_notifications.go
+++ b/apps/backend/internal/gateway/websocket/task_notifications.go
@@ -289,6 +289,15 @@ func (b *TaskEventBroadcaster) routeBroadcast(
// GitHub PR or GitLab MR update must never cross workspace boundaries.
b.hub.BroadcastToWorkspaceOrDrop(workspaceID, msg)
return nil
+ case ws.ActionAgentProfileCreated, ws.ActionAgentProfileUpdated, ws.ActionAgentProfileDeleted:
+ // Profile payloads wrap the profile DTO under "profile"; office-scoped
+ // profiles (nested workspace_id) must never cross workspace
+ // boundaries — route them fail-closed. Kanban profiles (empty
+ // workspace) are instance-wide and fall through to the global path.
+ if workspaceID != "" {
+ b.hub.BroadcastToWorkspaceOrDrop(workspaceID, msg)
+ return nil
+ }
}
// Workspace-carrying events (task/workflow/repository/…) route to the
// owner's clients; events without workspace context (executors,
@@ -298,12 +307,21 @@ func (b *TaskEventBroadcaster) routeBroadcast(
}
// extractWorkspaceID pulls a workspace ID from event payloads (map- or
-// struct-shaped). Empty means "no workspace context" — the event is treated
-// as instance-wide and broadcast to everyone.
+// struct-shaped, nested included). Profile events wrap the profile DTO under
+// "profile": the wrapper may be a map (JSON round-tripped bus) or a struct
+// (in-process bus, e.g. *dto.AgentProfileDTO from the MCP publisher), so the
+// nested value is inspected recursively and structs expose their ID via the
+// GetWorkspaceID interface. Empty means "no workspace context" — the event is
+// treated as instance-wide and broadcast to everyone.
func extractWorkspaceID(data interface{}) string {
if id := extractStringField(data, "workspace_id"); id != "" {
return id
}
+ if profile, ok := data.(map[string]interface{}); ok {
+ if id := extractWorkspaceID(profile["profile"]); id != "" {
+ return id
+ }
+ }
if provider, ok := data.(interface{ GetWorkspaceID() string }); ok {
return provider.GetWorkspaceID()
}
diff --git a/apps/web/app/actions/agents.ts b/apps/web/app/actions/agents.ts
index daa351d6d7..b97ada6eab 100644
--- a/apps/web/app/actions/agents.ts
+++ b/apps/web/app/actions/agents.ts
@@ -144,6 +144,20 @@ export async function updateAgentProfileAction(
return normalizeAgentProfile(raw);
}
+/**
+ * Duplicate a profile: the backend copies the source's full configuration
+ * into a new row named " copy" and returns the new profile. The
+ * existing `agent.profile.created` WS notification also picks the copy up in
+ * every open settings surface.
+ */
+export async function duplicateAgentProfileAction(id: string): Promise {
+ const raw = await agentSettingsRequest(
+ `${apiBaseUrl}/api/v1/agent-profiles/${id}/duplicate`,
+ { method: "POST" },
+ );
+ return normalizeAgentProfile(raw);
+}
+
import type {
ActiveSessionInfo,
AutomationReference,
diff --git a/apps/web/components/settings/agent-profile-duplicate-action.test.tsx b/apps/web/components/settings/agent-profile-duplicate-action.test.tsx
new file mode 100644
index 0000000000..a4a024446e
--- /dev/null
+++ b/apps/web/components/settings/agent-profile-duplicate-action.test.tsx
@@ -0,0 +1,190 @@
+import { act, cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { Agent, AgentProfile } from "@/lib/types/http";
+import { useProfileDuplicateAction } from "./agent-profile-duplicate-action";
+
+type ToastArgs = {
+ title?: string;
+ description?: string;
+ variant?: "default" | "success" | "error" | "loading";
+};
+
+const duplicateAction = vi.fn<(id: string) => Promise>();
+const saveAll = vi.fn<() => Promise<{ canLeave: boolean; failedIds: Set }>>();
+const cancelPendingNavigation = vi.fn<() => void>();
+const routerPush = vi.fn<(href: string) => void>();
+const toast = vi.fn<(args: ToastArgs) => void>();
+const setState = vi.fn<() => void>();
+
+const hoisted = vi.hoisted(() => ({
+ coordinatorInvalidReason: undefined as string | undefined,
+}));
+
+vi.mock("@/app/actions/agents", () => ({
+ duplicateAgentProfileAction: (id: string) => duplicateAction(id),
+}));
+vi.mock("@/components/state-provider", () => ({ useAppStoreApi: () => ({ setState }) }));
+vi.mock("@/components/toast-provider", () => ({ useToast: () => ({ toast }) }));
+vi.mock("@/components/settings/settings-save-provider", () => ({
+ useSettingsSaveCoordinator: () => ({
+ saveAll,
+ invalidReason: hoisted.coordinatorInvalidReason,
+ cancelPendingNavigation,
+ }),
+}));
+vi.mock("@/lib/routing/client-router", () => ({ useRouter: () => ({ push: routerPush }) }));
+vi.mock("@/lib/routing/navigation-guard", () => ({
+ runWithNavigationBlockerBypassed: (fn: () => void) => fn(),
+}));
+vi.mock("@/components/settings/agent-profile-page-state", () => ({
+ errorMessage: (error: unknown) => (error instanceof Error ? error.message : String(error)),
+}));
+
+/** Builds an Agent fixture for the duplicate-action harness. */
+function agent(): Agent {
+ return { id: "a1", name: "mock-agent", profiles: [] } as unknown as Agent;
+}
+
+type DraftOverrides = Partial> & {
+ id?: string;
+ agentId?: string;
+ name?: string;
+};
+
+/** Builds a profile draft (SettingsSaveContributor) for the duplicate-action harness. */
+function draft(overrides: DraftOverrides = {}): AgentProfile {
+ return {
+ id: "p1",
+ agentId: "a1",
+ name: "Default",
+ agentDisplayName: "Mock",
+ model: "mock-fast",
+ allowIndexing: false,
+ autoApprove: false,
+ cliFlags: [],
+ cliPassthrough: false,
+ enabled: true,
+ createdAt: "",
+ updatedAt: "",
+ ...overrides,
+ } as unknown as AgentProfile;
+}
+
+/** Renders the duplicate action with the settings save provider and navigation guard. */
+function Harness({ profileDraft = draft() }: { profileDraft?: AgentProfile }) {
+ const { handleDuplicate, duplicating } = useProfileDuplicateAction({
+ agent: agent(),
+ draft: profileDraft,
+ modelConfigResolutionPending: false,
+ translate: (key: string) => key,
+ });
+ return (
+
+ );
+}
+
+/** Reads the most recently pushed toast from the harness. */
+function lastToast(): ToastArgs {
+ const call = toast.mock.calls.at(-1);
+ return call ? call[0] : {};
+}
+
+afterEach(() => {
+ cleanup();
+ vi.clearAllMocks();
+ hoisted.coordinatorInvalidReason = undefined;
+});
+
+describe("useProfileDuplicateAction", () => {
+ it("aborts without POSTing when a contributor cannot save", async () => {
+ saveAll.mockResolvedValue({ canLeave: false, failedIds: new Set() });
+ render();
+
+ await act(async () => {
+ fireEvent.click(screen.getByRole("button", { name: "duplicate" }));
+ });
+
+ expect(duplicateAction).not.toHaveBeenCalled();
+ expect(routerPush).not.toHaveBeenCalled();
+ });
+
+ it("toasts the coordinator invalid reason when the profile draft is valid but MCP is not", async () => {
+ hoisted.coordinatorInvalidReason = "MCP server URL invalid";
+ saveAll.mockResolvedValue({ canLeave: false, failedIds: new Set() });
+ render();
+
+ await act(async () => {
+ fireEvent.click(screen.getByRole("button", { name: "duplicate" }));
+ });
+
+ expect(duplicateAction).not.toHaveBeenCalled();
+ expect(lastToast().description).toBe("MCP server URL invalid");
+ });
+
+ it("toasts the profile-name validation reason when the draft name is empty", async () => {
+ saveAll.mockResolvedValue({ canLeave: false, failedIds: new Set() });
+ render();
+
+ await act(async () => {
+ fireEvent.click(screen.getByRole("button", { name: "duplicate" }));
+ });
+
+ expect(duplicateAction).not.toHaveBeenCalled();
+ expect(lastToast().description).toBe("agents:profileNameRequired");
+ });
+
+ it("falls back to a generic toast when the save is blocked without a specific reason", async () => {
+ // canLeave=false with no invalidReason and a valid draft: another save is
+ // in flight or newer changes appeared. The abort must still be visible.
+ saveAll.mockResolvedValue({ canLeave: false, failedIds: new Set() });
+ render();
+
+ await act(async () => {
+ fireEvent.click(screen.getByRole("button", { name: "duplicate" }));
+ });
+
+ expect(duplicateAction).not.toHaveBeenCalled();
+ expect(lastToast().description).toBe("agents:duplicateSaveBlocked");
+ });
+
+ it("POSTs, merges, toasts, and SPA-navigates when the save succeeds", async () => {
+ saveAll.mockResolvedValue({ canLeave: true, failedIds: new Set() });
+ duplicateAction.mockResolvedValue(draft({ id: "p2", name: "Default Copy" }));
+ render();
+
+ await act(async () => {
+ fireEvent.click(screen.getByRole("button", { name: "duplicate" }));
+ });
+
+ expect(duplicateAction).toHaveBeenCalledTimes(1);
+ expect(duplicateAction).toHaveBeenCalledWith("p1");
+ expect(setState).toHaveBeenCalledTimes(1);
+ expect(cancelPendingNavigation).toHaveBeenCalledTimes(1);
+ expect(routerPush).toHaveBeenCalledWith("/settings/agents/mock-agent/profiles/p2");
+ expect(toast.mock.calls.some(([t]) => t?.title === "agents:duplicateProfileSuccess")).toBe(
+ true,
+ );
+ });
+
+ it("ignores a second click while the first duplicate is in flight", async () => {
+ saveAll.mockResolvedValue({ canLeave: true, failedIds: new Set() });
+ let resolveDuplicate: (value: AgentProfile) => void = () => undefined;
+ duplicateAction.mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ resolveDuplicate = resolve;
+ }),
+ );
+ render();
+
+ fireEvent.click(screen.getByRole("button", { name: "duplicate" }));
+ fireEvent.click(screen.getByRole("button", { name: "duplicate" }));
+ await act(async () => {
+ resolveDuplicate(draft({ id: "p2", name: "Default Copy" }));
+ });
+
+ expect(duplicateAction).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/apps/web/components/settings/agent-profile-duplicate-action.ts b/apps/web/components/settings/agent-profile-duplicate-action.ts
new file mode 100644
index 0000000000..e1a8d07878
--- /dev/null
+++ b/apps/web/components/settings/agent-profile-duplicate-action.ts
@@ -0,0 +1,133 @@
+"use client";
+
+/**
+ * Header duplicate action for the agent profile settings page, extracted so
+ * the page stays presentation-only and the save-gate + in-flight guard are
+ * unit-testable. Mirrors the agent-profile-page-state.ts split.
+ */
+
+import { useCallback, useRef, useState } from "react";
+import { duplicateAgentProfileAction } from "@/app/actions/agents";
+import { useAppStoreApi } from "@/components/state-provider";
+import { useToast } from "@/components/toast-provider";
+import { useSettingsSaveCoordinator } from "@/components/settings/settings-save-provider";
+import { applyProfileDuplicated } from "@/hooks/domains/settings/use-profile-duplicate";
+import { errorMessage } from "@/components/settings/agent-profile-page-state";
+import { useRouter } from "@/lib/routing/client-router";
+import { runWithNavigationBlockerBypassed } from "@/lib/routing/navigation-guard";
+import type { Agent, AgentProfile } from "@/lib/types/http";
+
+/**
+ * Returns the localized reason a profile draft cannot be saved yet (missing
+ * name or model resolution still pending), or undefined when it is savable.
+ */
+export function profileSaveInvalidReason(
+ profileName: string,
+ modelConfigResolutionPending: boolean,
+ translate: (key: string) => string,
+): string | undefined {
+ if (!profileName.trim()) return translate("agents:profileNameRequired");
+ if (modelConfigResolutionPending) return translate("agents:resolvingModelOptions");
+ return undefined;
+}
+
+type UseProfileDuplicateActionOptions = {
+ agent: Agent;
+ draft: AgentProfile;
+ modelConfigResolutionPending: boolean;
+ translate: (key: string) => string;
+};
+
+/**
+ * Header "Duplicate" flow: save every dirty contributor (profile editor AND
+ * MCP card) through the shared settings coordinator — aborting with the
+ * blocking contributor's reason when anything is invalid — then POST the
+ * duplicate, merge the copy into the store, toast, and SPA-navigate to the
+ * copy's page. The in-flight guard is a ref (synchronous) so two rapid clicks
+ * can never issue two copies; the state only drives the button's disabled
+ * state.
+ */
+export function useProfileDuplicateAction({
+ agent,
+ draft,
+ modelConfigResolutionPending,
+ translate,
+}: UseProfileDuplicateActionOptions) {
+ const storeApi = useAppStoreApi();
+ const router = useRouter();
+ const { saveAll, invalidReason, cancelPendingNavigation } = useSettingsSaveCoordinator();
+ const { toast } = useToast();
+ const [duplicating, setDuplicating] = useState(false);
+ const inFlightRef = useRef(false);
+
+ const handleDuplicate = useCallback(async () => {
+ if (inFlightRef.current) return;
+ inFlightRef.current = true;
+ setDuplicating(true);
+ try {
+ // Save EVERY dirty contributor (the profile editor AND the MCP card)
+ // so the copy starts from what the user sees. saveAll respects each
+ // contributor's canSave; when anything is invalid or fails to persist,
+ // it reports canLeave=false and we abort before posting.
+ const saved = await saveAll();
+ if (!saved.canLeave) {
+ // Surface whichever contributor is blocking the save (MCP error or
+ // an invalid profile draft); when the coordinator gives no reason
+ // (another save in flight, or newer changes appeared during the
+ // awaited save), fall back to a generic message so the abort is
+ // never silent.
+ toast({
+ title: translate("agents:failedToDuplicateProfile"),
+ description:
+ invalidReason ??
+ profileSaveInvalidReason(draft.name, modelConfigResolutionPending, translate) ??
+ translate("agents:duplicateSaveBlocked"),
+ variant: "error",
+ });
+ return;
+ }
+ const created = await duplicateAgentProfileAction(draft.id);
+ // Merge the copy into the store so the destination page resolves it
+ // without waiting on the WS round-trip.
+ storeApi.setState((state) => applyProfileDuplicated(state, agent, created));
+ toast({
+ title: translate("agents:duplicateProfileSuccess"),
+ description: created.name,
+ variant: "success",
+ });
+ // Supersede any navigation intent the dirty guard blocked (e.g. a
+ // browser-back while dirty) — this duplicate navigation replaces it.
+ cancelPendingNavigation();
+ // SPA navigation, not location.assign: the toast survives the route
+ // change and the dirty-settings blocker was already resolved by the
+ // save above (the bypass is the pattern the executor editors use
+ // after an awaited save).
+ runWithNavigationBlockerBypassed(() =>
+ router.push(`/settings/agents/${encodeURIComponent(agent.name)}/profiles/${created.id}`),
+ );
+ } catch (error) {
+ toast({
+ title: translate("agents:failedToDuplicateProfile"),
+ description: errorMessage(error),
+ variant: "error",
+ });
+ } finally {
+ inFlightRef.current = false;
+ setDuplicating(false);
+ }
+ }, [
+ agent,
+ cancelPendingNavigation,
+ draft.id,
+ draft.name,
+ invalidReason,
+ modelConfigResolutionPending,
+ router,
+ saveAll,
+ storeApi,
+ toast,
+ translate,
+ ]);
+
+ return { handleDuplicate, duplicating };
+}
diff --git a/apps/web/components/settings/agent-profile-page-state.test.ts b/apps/web/components/settings/agent-profile-page-state.test.ts
new file mode 100644
index 0000000000..0f00596f3c
--- /dev/null
+++ b/apps/web/components/settings/agent-profile-page-state.test.ts
@@ -0,0 +1,132 @@
+import { describe, expect, it, vi } from "vitest";
+import type { Agent } from "@/lib/types/http";
+import type { AgentProfileOption } from "@/lib/state/slices/settings/types";
+import { reconcileAgentProfileOptions } from "./agent-profile-page-state";
+
+vi.mock("@/app/actions/agents", () => ({
+ deleteAgentProfileAction: vi.fn(),
+ updateAgentProfileAction: vi.fn(),
+}));
+vi.mock("@/components/state-provider", () => ({ useAppStore: vi.fn(), useAppStoreApi: vi.fn() }));
+vi.mock("@/lib/i18n", () => ({ t: (key: string) => key }));
+
+/** Builds an Agent fixture with the given profile names. */
+function agent(id: string, ...profileNames: string[]): Agent {
+ return {
+ id,
+ name: id,
+ profiles: profileNames.map((name) => ({
+ id: name,
+ agentId: id,
+ name,
+ agentDisplayName: "Test Agent",
+ model: "",
+ allowIndexing: false,
+ autoApprove: false,
+ cliFlags: [],
+ cliPassthrough: false,
+ enabled: true,
+ createdAt: "",
+ updatedAt: "",
+ })),
+ } as unknown as Agent;
+}
+
+/** Builds an AgentProfileOption fixture with an optional updatedAt. */
+function option(id: string, updatedAt = ""): AgentProfileOption {
+ return {
+ id,
+ label: id,
+ agent_id: "a1",
+ agent_name: "a1",
+ cli_passthrough: false,
+ updatedAt,
+ };
+}
+
+describe("reconcileAgentProfileOptions", () => {
+ it("rebuilds options from the next agent list", () => {
+ const next = reconcileAgentProfileOptions([], [agent("a1", "p1", "p2")]);
+ expect(next.map((o) => o.id).sort()).toEqual(["p1", "p2"]);
+ });
+
+ it("preserves WS-delivered orphan options the rebuild does not represent", () => {
+ // p-orphan was delivered by WS for an agent absent from the next list.
+ const next = reconcileAgentProfileOptions([option("p-orphan")], [agent("a1", "p1")]);
+ const ids = next.map((o) => o.id);
+ expect(ids).toContain("p-orphan");
+ expect(ids).toContain("p1");
+ });
+
+ it("replaces stale options with the rebuilt versions by id", () => {
+ const next = reconcileAgentProfileOptions([option("p1")], [agent("a1", "p1")]);
+ expect(next.filter((o) => o.id === "p1")).toHaveLength(1);
+ expect(next.find((o) => o.id === "p1")?.label).toContain("p1");
+ });
+
+ it("keeps a newer existing option over a stale rebuilt one", () => {
+ // WS updated the option (enabled=false, newer revision) while the next
+ // agent list carries a stale profile. The rebuild must not regress it.
+ const staleProfile = {
+ id: "a1",
+ name: "a1",
+ profiles: [
+ {
+ id: "p1",
+ agentId: "a1",
+ name: "p1",
+ agentDisplayName: "Test Agent",
+ model: "",
+ allowIndexing: false,
+ autoApprove: false,
+ cliFlags: [],
+ cliPassthrough: false,
+ enabled: true,
+ createdAt: "",
+ updatedAt: "2026-08-11T21:00:00Z",
+ },
+ ],
+ } as unknown as Agent;
+ const newerOption = { ...option("p1", "2026-08-11T22:00:00Z"), enabled: false };
+
+ const next = reconcileAgentProfileOptions([newerOption], [staleProfile]);
+
+ const options = next.filter((o) => o.id === "p1");
+ expect(options).toHaveLength(1);
+ expect(options[0].enabled).toBe(false);
+ expect(options[0].updatedAt).toBe("2026-08-11T22:00:00Z");
+ });
+
+ it("keeps a fractional-second newer option over a whole-second rebuilt one", () => {
+ // Lexically "…22:00:00Z" sorts after "…22:00:00.100Z" despite being
+ // older, so revision precedence must compare instants, not strings.
+ const staleProfile = {
+ id: "a1",
+ name: "a1",
+ profiles: [
+ {
+ id: "p1",
+ agentId: "a1",
+ name: "p1",
+ agentDisplayName: "Test Agent",
+ model: "",
+ allowIndexing: false,
+ autoApprove: false,
+ cliFlags: [],
+ cliPassthrough: false,
+ enabled: true,
+ createdAt: "",
+ updatedAt: "2026-08-11T22:00:00Z",
+ },
+ ],
+ } as unknown as Agent;
+ const fractionalOption = { ...option("p1", "2026-08-11T22:00:00.100Z"), enabled: false };
+
+ const next = reconcileAgentProfileOptions([fractionalOption], [staleProfile]);
+
+ const options = next.filter((o) => o.id === "p1");
+ expect(options).toHaveLength(1);
+ expect(options[0].enabled).toBe(false);
+ expect(options[0].updatedAt).toBe("2026-08-11T22:00:00.100Z");
+ });
+});
diff --git a/apps/web/components/settings/agent-profile-page-state.ts b/apps/web/components/settings/agent-profile-page-state.ts
index d3c323c029..5cc87f605c 100644
--- a/apps/web/components/settings/agent-profile-page-state.ts
+++ b/apps/web/components/settings/agent-profile-page-state.ts
@@ -12,26 +12,47 @@
import { useMemo, useState } from "react";
import { permissionsToProfilePatch } from "@/lib/agent-permissions";
import { deleteAgentProfileAction, updateAgentProfileAction } from "@/app/actions/agents";
-import { useAppStore } from "@/components/state-provider";
+import { useAppStore, useAppStoreApi } from "@/components/state-provider";
import { isProfileDirty } from "@/components/settings/agent-profile-dirty";
import type { useToast } from "@/components/toast-provider";
import type { AgentProfileDeleteConflict } from "@/components/settings/agent-profile-delete-dialog";
import { t as translate } from "@/lib/i18n";
-import { toAgentProfileOption } from "@/lib/state/slices/settings/types";
+import {
+ mergeOptionsByNewest,
+ toAgentProfileOption,
+ type AgentProfileOption,
+} from "@/lib/state/slices/settings/types";
import { ApiError } from "@/lib/api/client";
import type { Agent, AgentProfile, PermissionSetting } from "@/lib/types/http";
export type SaveStatus = "idle" | "loading" | "success" | "error";
+/**
+ * Reconcile the options slice with the next agent list by ID: options the
+ * rebuild does not represent (e.g. profiles the WS handler delivered for
+ * agents temporarily absent from `settingsAgents`) are preserved, and rebuilt
+ * options replace any stale versions. Same rule as
+ * `applyProfileDuplicated` in the duplicate hook — a save must never wipe
+ * orphan options.
+ */
+export function reconcileAgentProfileOptions(
+ previousOptions: AgentProfileOption[],
+ nextAgents: Agent[],
+): AgentProfileOption[] {
+ const rebuiltOptions = nextAgents.flatMap((agentItem) =>
+ agentItem.profiles.map((agentProfile) => toAgentProfileOption(agentItem, agentProfile)),
+ );
+ return mergeOptionsByNewest(previousOptions, rebuiltOptions);
+}
+
export function useSyncAgentsToStore() {
const setSettingsAgents = useAppStore((state) => state.setSettingsAgents);
const setAgentProfiles = useAppStore((state) => state.setAgentProfiles);
+ const storeApi = useAppStoreApi();
return (nextAgents: Agent[]) => {
setSettingsAgents(nextAgents);
setAgentProfiles(
- nextAgents.flatMap((agentItem) =>
- agentItem.profiles.map((agentProfile) => toAgentProfileOption(agentItem, agentProfile)),
- ),
+ reconcileAgentProfileOptions(storeApi.getState().agentProfiles.items, nextAgents),
);
};
}
diff --git a/apps/web/components/settings/agent-profile-page.tsx b/apps/web/components/settings/agent-profile-page.tsx
index 7d86bda65a..4504467943 100644
--- a/apps/web/components/settings/agent-profile-page.tsx
+++ b/apps/web/components/settings/agent-profile-page.tsx
@@ -4,7 +4,7 @@ import { useCallback, useState } from "react";
import { useTranslation } from "react-i18next";
import Link from "@/components/routing/app-link";
import { useParams } from "@/lib/routing/client-router";
-import { IconTrash } from "@tabler/icons-react";
+import { IconCopy, IconTrash } from "@tabler/icons-react";
import { Badge } from "@kandev/ui/badge";
import { Button } from "@kandev/ui/button";
import { Card, CardContent, CardHeader, CardTitle } from "@kandev/ui/card";
@@ -33,6 +33,10 @@ import {
useProfileSave,
useSyncAgentsToStore,
} from "@/components/settings/agent-profile-page-state";
+import {
+ profileSaveInvalidReason,
+ useProfileDuplicateAction,
+} from "@/components/settings/agent-profile-duplicate-action";
import { CustomCLIFlagsCard } from "@/components/settings/cli-flags-field";
import { ProfileEnabledHelp } from "@/components/settings/profile-enabled-help";
@@ -73,24 +77,18 @@ type ProfileEditorHeaderProps = {
savedProfileName: string;
enabled: boolean;
onEnabledChange: (enabled: boolean) => void;
+ onDuplicate: () => void;
+ duplicating: boolean;
};
-function profileSaveInvalidReason(
- profileName: string,
- modelConfigResolutionPending: boolean,
- translate: (key: string) => string,
-): string | undefined {
- if (!profileName.trim()) return translate("agents:profileNameRequired");
- if (modelConfigResolutionPending) return translate("agents:resolvingModelOptions");
- return undefined;
-}
-
function ProfileEditorHeader({
agentName,
agentDisplayName,
savedProfileName,
enabled,
onEnabledChange,
+ onDuplicate,
+ duplicating,
}: ProfileEditorHeaderProps) {
const { t } = useTranslation();
return (
@@ -105,6 +103,18 @@ function ProfileEditorHeader({
+
{t("agents:enabled")}
@@ -403,6 +413,13 @@ function ProfileEditor({
});
const deleteState = useProfileDelete(agent, draft, settingsAgents, syncAgentsToStore, toast);
+ const { handleDuplicate: handleDuplicateProfile, duplicating } = useProfileDuplicateAction({
+ agent,
+ draft,
+ modelConfigResolutionPending,
+ translate: t,
+ });
+
return (
updateDraft({ enabled: next })}
+ onDuplicate={() => void handleDuplicateProfile()}
+ duplicating={duplicating}
/>
diff --git a/apps/web/components/settings/agents/agent-profiles-section.test.tsx b/apps/web/components/settings/agents/agent-profiles-section.test.tsx
index 05de88d4c0..c3b07cbfc5 100644
--- a/apps/web/components/settings/agents/agent-profiles-section.test.tsx
+++ b/apps/web/components/settings/agents/agent-profiles-section.test.tsx
@@ -6,6 +6,7 @@ import type { Agent, AgentProfile } from "@/lib/types/http";
const mocks = vi.hoisted(() => ({
deleteAgentProfileAction: vi.fn(),
+ duplicateAgentProfileAction: vi.fn(),
toast: vi.fn(),
routerPush: vi.fn(),
}));
@@ -41,11 +42,12 @@ const selectors = {
vi.mock("@/components/state-provider", () => ({
useAppStore: (selector: (s: unknown) => unknown) => selector({ ...storeState, ...selectors }),
- useAppStoreApi: () => ({ getState: () => storeState }),
+ useAppStoreApi: () => ({ getState: () => storeState, setState: vi.fn() }),
}));
vi.mock("@/app/actions/agents", () => ({
deleteAgentProfileAction: mocks.deleteAgentProfileAction,
+ duplicateAgentProfileAction: mocks.duplicateAgentProfileAction,
}));
vi.mock("@/components/toast-provider", () => ({
@@ -68,8 +70,16 @@ vi.mock("@kandev/ui/dropdown-menu", () => ({
DropdownMenu: ({ children }: { children?: ReactNode }) => {children}
,
DropdownMenuTrigger: ({ children }: { children?: ReactNode }) => <>{children}>,
DropdownMenuContent: ({ children }: { children?: ReactNode }) => {children}
,
- DropdownMenuItem: ({ children, onSelect }: { children?: ReactNode; onSelect?: () => void }) => (
-
-
-
-
-
-
-
-
- setConfirmOpen(true)}
- >
-
- {t("agents:delete")}
-
-
-
+
setConfirmOpen(true)}
+ />
Promise | void;
+}) {
+ const [revision, setRevision] = useState(1);
+ const [savedRevision, setSavedRevision] = useState(1); // starts clean
+
+ useSettingsSaveContributor({
+ id,
+ revision,
+ isDirty: revision !== savedRevision,
+ save: async () => {
+ await onSave();
+ setSavedRevision(revision);
+ },
+ discard: () => setRevision(savedRevision),
+ });
+
+ return (
+ setRevision((current) => current + 1)}>
+ Edit {id}
+
+ );
+}
+
function BooleanDraftContributor({ pending }: { pending: Deferred }) {
const [draft, setDraft] = useState(true);
const [baseline, setBaseline] = useState(false);
@@ -456,13 +486,13 @@ describe("SettingsSaveProvider navigation", () => {
);
fireEvent.click(screen.getByRole("link", { name: "Terminal" }));
- fireEvent.click(await screen.findByRole("button", { name: "Save and leave" }));
+ fireEvent.click(await screen.findByRole("button", { name: SAVE_AND_LEAVE_LABEL }));
expect(await screen.findByText("Couldn't save")).toBeTruthy();
expect(window.location.pathname).toBe(APPEARANCE_PATH);
shouldFail = false;
- fireEvent.click(screen.getByRole("button", { name: "Save and leave" }));
+ fireEvent.click(screen.getByRole("button", { name: SAVE_AND_LEAVE_LABEL }));
await waitFor(() => expect(window.location.pathname).toBe(TERMINAL_PATH));
});
@@ -477,7 +507,7 @@ describe("SettingsSaveProvider navigation", () => {
);
fireEvent.click(screen.getByRole("link", { name: "Terminal" }));
- fireEvent.click(await screen.findByRole("button", { name: "Save and leave" }));
+ fireEvent.click(await screen.findByRole("button", { name: SAVE_AND_LEAVE_LABEL }));
await waitFor(() => expect(window.location.pathname).toBe(TERMINAL_PATH));
});
@@ -507,6 +537,73 @@ describe("SettingsSaveProvider navigation", () => {
});
});
+describe("SettingsSaveProvider mid-save edits", () => {
+ it("stays put when a contributor becomes dirty while the save is in flight", async () => {
+ window.history.replaceState({}, "", APPEARANCE_PATH);
+ const pending = deferred();
+
+ render(
+
+ pending.promise} />
+
+ Terminal
+ ,
+ );
+
+ fireEvent.click(screen.getByRole("button", { name: "Edit appearance" }));
+ fireEvent.click(screen.getByRole("link", { name: "Terminal" }));
+ fireEvent.click(await screen.findByRole("button", { name: SAVE_AND_LEAVE_LABEL }));
+ // The MCP contributor (clean at the save snapshot) becomes dirty while
+ // the appearance save is pending. Radix aria-hides the page behind the
+ // modal, so query with hidden:true.
+ fireEvent.click(screen.getByRole("button", { name: "Edit mcp", hidden: true }));
+
+ await act(async () => pending.resolve());
+
+ // The newly dirty contributor blocks leaving: the navigation must not
+ // proceed (saveAll reports canLeave=false).
+ await waitFor(() => expect(window.location.pathname).toBe(APPEARANCE_PATH));
+ expect(screen.getByRole("button", { name: SAVE_AND_LEAVE_LABEL })).toBeTruthy();
+ });
+
+ it("does not treat a re-rendered same-id contributor as newly dirty mid-save", async () => {
+ window.history.replaceState({}, "", APPEARANCE_PATH);
+ const pending = deferred();
+ const onSave = vi.fn(() => pending.promise);
+
+ function PokingContributor() {
+ const [, setPoke] = useState(0);
+ return (
+ <>
+
+ setPoke((n) => n + 1)}>
+ Poke appearance
+
+ >
+ );
+ }
+
+ render(
+
+
+ Terminal
+ ,
+ );
+
+ fireEvent.click(screen.getByRole("button", { name: "Edit appearance" }));
+ fireEvent.click(screen.getByRole("link", { name: "Terminal" }));
+ fireEvent.click(await screen.findByRole("button", { name: SAVE_AND_LEAVE_LABEL }));
+ // Re-render the contributor while its save is pending: the registry
+ // replaces the contributor object on every upsert, so an identity-based
+ // "newly dirty" check would wrongly block leaving. Same id must not count.
+ fireEvent.click(screen.getByRole("button", { name: "Poke appearance", hidden: true }));
+
+ await act(async () => pending.resolve());
+
+ await waitFor(() => expect(window.location.pathname).toBe(TERMINAL_PATH));
+ });
+});
+
describe("SettingsSaveProvider reset coordination", () => {
it("settles navigation requested while a standalone reset is pending", async () => {
window.history.replaceState({}, "", APPEARANCE_PATH);
diff --git a/apps/web/components/settings/settings-save-provider.tsx b/apps/web/components/settings/settings-save-provider.tsx
index c6dcc1be64..48345c006c 100644
--- a/apps/web/components/settings/settings-save-provider.tsx
+++ b/apps/web/components/settings/settings-save-provider.tsx
@@ -63,6 +63,23 @@ type SaveResult = {
const SettingsSaveRegistryContext = createContext(null);
const SettingsDirtyScopeContext = createContext(null);
+export type SettingsSaveCoordinator = {
+ /** Save every dirty contributor. Respects each contributor's canSave;
+ * returns canLeave=false when any contributor is invalid or fails. */
+ saveAll: () => Promise;
+ status: SettingsSaveStatus;
+ errorKind: SettingsSaveErrorKind | null;
+ hasDirty: boolean;
+ /** Reason why the first invalid dirty contributor cannot be saved, if any. */
+ invalidReason: string | undefined;
+ /** Cancel a navigation intent blocked by the dirty guard (the caller is
+ * superseding it with its own navigation). */
+ cancelPendingNavigation: () => void;
+ clearSavedStatus: () => void;
+};
+
+const SettingsSaveCoordinatorContext = createContext(null);
+
export function SettingsSaveProvider({
children,
placement = "viewport",
@@ -75,10 +92,6 @@ export function SettingsSaveProvider({
contributors,
refreshRegistry,
);
- const pendingNavigationRef = useRef(null);
- const discardingRef = useRef(false);
- const [pendingNavigation, setPendingNavigation] = useState(null);
- const [isDiscarding, setIsDiscarding] = useState(false);
const hasDirty = dirtyContributors.length > 0;
const invalidReason = dirtyContributors.find(({ contributor }) => contributor.canSave === false)
?.contributor.invalidReason;
@@ -90,6 +103,153 @@ export function SettingsSaveProvider({
return () => window.clearTimeout(timeout);
}, [clearSavedStatus, status]);
+ const {
+ pendingNavigation,
+ isDiscarding,
+ handleSave,
+ discardDirtyContributors,
+ discardAndLeave,
+ continueEditing,
+ } = useSaveNavigationFlow({ saveAll, contributors, markError, refreshRegistry, hasDirty });
+
+ useSettingsBeforeUnloadGuard(hasDirty);
+
+ return (
+ contributor.id).join(",")}
+ invalidReason={invalidReason}
+ pendingNavigation={pendingNavigation}
+ isDiscarding={isDiscarding}
+ onSave={handleSave}
+ onReset={discardDirtyContributors}
+ onDiscardAndLeave={discardAndLeave}
+ onContinueEditing={continueEditing}
+ >
+ {children}
+
+ );
+}
+
+type SettingsSaveProviderBodyProps = {
+ registry: Registry;
+ coordinator: SettingsSaveCoordinator;
+ placement: SettingsSavePlacement;
+ displayStatus: SettingsSaveStatus;
+ errorKind: SettingsSaveErrorKind | null;
+ dirtyContributorIds: string;
+ invalidReason: string | undefined;
+ pendingNavigation: NavigationIntent | null;
+ isDiscarding: boolean;
+ onSave: () => Promise;
+ onReset: () => Promise;
+ onDiscardAndLeave: () => Promise;
+ onContinueEditing: () => void;
+ children: ReactNode;
+};
+
+/**
+ * Renders the provider's context stack (registry + coordinator) around the
+ * page content and the floating save bar/dialog. Extracted to keep
+ * SettingsSaveProvider under the line limit.
+ */
+function SettingsSaveProviderBody({
+ registry,
+ coordinator,
+ placement,
+ displayStatus,
+ errorKind,
+ dirtyContributorIds,
+ invalidReason,
+ pendingNavigation,
+ isDiscarding,
+ onSave,
+ onReset,
+ onDiscardAndLeave,
+ onContinueEditing,
+ children,
+}: SettingsSaveProviderBodyProps) {
+ const hasDirty = coordinator.hasDirty;
+ return (
+
+
+ {children}
+ {(hasDirty || displayStatus === "saved") && (
+
+ )}
+
+
+ );
+}
+
+/**
+ * Imperative handle on the shared settings save coordinator: save every dirty
+ * contributor (across pages that register multiple contributors, e.g. the
+ * profile editor and its MCP card) and learn whether the page can be left.
+ * Requires SettingsSaveProvider.
+ */
+export function useSettingsSaveCoordinator(): SettingsSaveCoordinator {
+ const coordinator = useContext(SettingsSaveCoordinatorContext);
+ if (!coordinator) throw new Error("useSettingsSaveCoordinator requires SettingsSaveProvider");
+ return coordinator;
+}
+
+/**
+ * Owns the save/discard/continue actions and the dirty-navigation blocker:
+ * registers the blocker while anything is dirty, saves and settles a pending
+ * navigation intent, or discards the dirty contributors and leaves.
+ */
+function useSaveNavigationFlow({
+ saveAll,
+ contributors,
+ markError,
+ refreshRegistry,
+ hasDirty,
+}: {
+ saveAll: () => Promise;
+ contributors: Map;
+ markError: (kind: SettingsSaveErrorKind) => void;
+ refreshRegistry: () => void;
+ hasDirty: boolean;
+}) {
+ const pendingNavigationRef = useRef(null);
+ const discardingRef = useRef(false);
+ const [pendingNavigation, setPendingNavigation] = useState(null);
+ const [isDiscarding, setIsDiscarding] = useState(false);
+
+ useEffect(() => {
+ if (!hasDirty) return;
+ return setNavigationBlocker((intent) => {
+ pendingNavigationRef.current?.cancel();
+ pendingNavigationRef.current = intent;
+ setPendingNavigation(intent);
+ });
+ }, [hasDirty]);
+
const handleSave = useCallback(async (): Promise => {
const result = await saveAll();
if (!result.canLeave) return false;
@@ -136,37 +296,14 @@ export function SettingsSaveProvider({
intent?.cancel();
}, []);
- useEffect(() => {
- if (!hasDirty) return;
- return setNavigationBlocker((intent) => {
- pendingNavigationRef.current?.cancel();
- pendingNavigationRef.current = intent;
- setPendingNavigation(intent);
- });
- }, [hasDirty]);
-
- useSettingsBeforeUnloadGuard(hasDirty);
-
- return (
-
- {children}
- {(hasDirty || status === "saved") && (
- contributor.id).join(",")}
- invalidReason={invalidReason}
- navigationIntent={pendingNavigation}
- isDiscarding={isDiscarding}
- onSave={handleSave}
- onReset={discardDirtyContributors}
- onDiscardAndLeave={discardAndLeave}
- onContinueEditing={continueEditing}
- />
- )}
-
- );
+ return {
+ pendingNavigation,
+ isDiscarding,
+ handleSave,
+ discardDirtyContributors,
+ discardAndLeave,
+ continueEditing,
+ };
}
function useSettingsBeforeUnloadGuard(enabled: boolean) {
@@ -299,11 +436,25 @@ function useSaveCoordinator(
}
savingRef.current = false;
+ // Revalidate the whole registry before reporting canLeave: a contributor
+ // that became dirty while the saves were in flight (e.g. the MCP card
+ // edited during the profile save) is absent from the submitted snapshot
+ // and would otherwise be skipped while the caller proceeds on stale data.
+ // Compare by id: the registry replaces the contributor object on every
+ // upsert, so an identity check would report submitted contributors as
+ // newly dirty after any re-render and block save-and-leave.
+ const submittedIds = new Set(submitted.map(({ contributor }) => contributor.id));
+ const newlyDirty = getDirtyContributors(contributors).filter(
+ ({ contributor }) => !submittedIds.has(contributor.id),
+ );
const completionStatus = saveCompletionStatus(failedIds, hasNewerChanges);
setErrorKind(completionStatus === "error" ? "save" : null);
setStatus(completionStatus);
refreshRegistry();
- return { canLeave: failedIds.size === 0 && !hasNewerChanges, failedIds };
+ return {
+ canLeave: failedIds.size === 0 && !hasNewerChanges && newlyDirty.length === 0,
+ failedIds,
+ };
}, [contributors, refreshRegistry]);
return { status, errorKind, saveAll, clearSavedStatus, markError };
diff --git a/apps/web/e2e/tests/settings/agent-profile-duplicate.spec.ts b/apps/web/e2e/tests/settings/agent-profile-duplicate.spec.ts
new file mode 100644
index 0000000000..6dda3153fa
--- /dev/null
+++ b/apps/web/e2e/tests/settings/agent-profile-duplicate.spec.ts
@@ -0,0 +1,131 @@
+import { test, expect } from "../../fixtures/test-base";
+
+/**
+ * Verifies the agent profile duplicate flow:
+ *
+ * - The /settings/agents profile list shows a Duplicate button per row.
+ * - Clicking it creates a " Copy" profile that appears in the list
+ * without a page reload, copying the source's model.
+ * - The copy is an independent profile with its own settings page.
+ *
+ * Uses the seeded default profile (like agent-profile-disable.spec.ts)
+ * rather than creating one: the profile list is hydrated on the server, so a
+ * freshly POSTed profile race-conditions with SSR.
+ */
+test.describe("Agent profile duplicate", () => {
+ test("duplicates the seeded profile from the settings list", async ({ testPage, apiClient }) => {
+ test.setTimeout(90_000);
+
+ const { agents } = await apiClient.listAgents();
+ const agent = agents[0];
+ const profile = agent.profiles[0];
+ const copyName = `${profile.name} Copy`;
+
+ try {
+ await testPage.goto("/settings/agents");
+
+ // The per-row Duplicate action lives in the row's actions dropdown.
+ const row = testPage.getByTestId("agent-profile-row").filter({ hasText: profile.name });
+ await expect(row).toBeVisible({ timeout: 15_000 });
+ await row.getByRole("button", { name: "Profile actions" }).click();
+ const duplicate = testPage.getByTestId(`duplicate-profile-${profile.id}`);
+ await expect(duplicate).toBeVisible({ timeout: 15_000 });
+ await duplicate.click();
+
+ // Backend state: the copy is a new row with the source's model. The
+ // duplicate POST is synchronous, so listAgents reflects it immediately.
+ let copy: { id: string; model: string } | undefined;
+ await expect
+ .poll(
+ async () => {
+ const { agents: after } = await apiClient.listAgents();
+ const afterAgent = after.find((a) => a.id === agent.id);
+ copy = afterAgent?.profiles.find((p) => p.name === copyName);
+ return copy?.id;
+ },
+ { timeout: 15_000 },
+ )
+ .toBeTruthy();
+ expect(copy?.id).not.toBe(profile.id);
+ expect(copy?.model).toBe(profile.model);
+
+ // The copy row appears in the list without a reload. Its row link is
+ // the unambiguous handle (the sidebar shows a sibling link with a
+ // different accessible name).
+ await expect(testPage.getByRole("link", { name: copyName, exact: true })).toBeVisible({
+ timeout: 15_000,
+ });
+
+ // The copy has its own settings page showing the copied name.
+ await testPage.goto(`/settings/agents/${agent.name}/profiles/${copy?.id}`);
+ await expect(
+ testPage.getByRole("heading", {
+ name: new RegExp(copyName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")),
+ }),
+ ).toBeVisible({ timeout: 15_000 });
+ } finally {
+ const { agents: cleanupAgents } = await apiClient.listAgents().catch(() => ({
+ agents: [] as typeof agents,
+ }));
+ const cleanupAgent = cleanupAgents.find((a) => a.id === agent.id);
+ const copy = cleanupAgent?.profiles.find((p) => p.name === copyName);
+ if (copy) {
+ await apiClient.deleteAgentProfile(copy.id, true).catch(() => {});
+ }
+ }
+ });
+
+ test("duplicates from the profile page header and navigates to the copy", async ({
+ testPage,
+ apiClient,
+ }) => {
+ test.setTimeout(90_000);
+
+ const { agents } = await apiClient.listAgents();
+ const agent = agents[0];
+ const profile = agent.profiles[0];
+ const copyName = `${profile.name} Copy`;
+
+ try {
+ await testPage.goto(`/settings/agents/${agent.name}/profiles/${profile.id}`);
+ const headerDuplicate = testPage.getByTestId("duplicate-profile-header");
+ await expect(headerDuplicate).toBeVisible({ timeout: 15_000 });
+ await headerDuplicate.click();
+
+ // The copy exists server-side and the SPA navigates to its page (no
+ // full reload: the URL changes to the copy's profile route).
+ let copy: { id: string } | undefined;
+ await expect
+ .poll(
+ async () => {
+ const { agents: after } = await apiClient.listAgents();
+ const afterAgent = after.find((a) => a.id === agent.id);
+ copy = afterAgent?.profiles.find((p) => p.name === copyName);
+ return copy?.id;
+ },
+ { timeout: 15_000 },
+ )
+ .toBeTruthy();
+ expect(copy?.id).not.toBe(profile.id);
+ await expect(testPage).toHaveURL(new RegExp(`/profiles/${copy?.id}$`), {
+ timeout: 15_000,
+ });
+
+ // The copy page renders the copy's name in its header.
+ await expect(
+ testPage.getByRole("heading", {
+ name: new RegExp(copyName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")),
+ }),
+ ).toBeVisible({ timeout: 15_000 });
+ } finally {
+ const { agents: cleanupAgents } = await apiClient.listAgents().catch(() => ({
+ agents: [] as typeof agents,
+ }));
+ const cleanupAgent = cleanupAgents.find((a) => a.id === agent.id);
+ const copy = cleanupAgent?.profiles.find((p) => p.name === copyName);
+ if (copy) {
+ await apiClient.deleteAgentProfile(copy.id, true).catch(() => {});
+ }
+ }
+ });
+});
diff --git a/apps/web/e2e/tests/settings/mobile-agent-profile-duplicate.spec.ts b/apps/web/e2e/tests/settings/mobile-agent-profile-duplicate.spec.ts
new file mode 100644
index 0000000000..4ff1083573
--- /dev/null
+++ b/apps/web/e2e/tests/settings/mobile-agent-profile-duplicate.spec.ts
@@ -0,0 +1,79 @@
+import { test, expect } from "../../fixtures/test-base";
+
+/**
+ * Mobile parity for the agent profile duplicate flow: the row-level
+ * Duplicate control must be reachable by touch on a phone viewport (the
+ * 44px hitbox), complete the same copy, and keep the document free of
+ * horizontal overflow. Uses the seeded default profile like the desktop
+ * spec: the /settings/agents list is server-hydrated, so a freshly POSTed
+ * profile would race with SSR.
+ */
+test.describe("Mobile agent profile duplicate", () => {
+ test("duplicates the seeded profile from the settings list", async ({ testPage, apiClient }) => {
+ test.setTimeout(90_000);
+
+ const { agents } = await apiClient.listAgents();
+ const agent = agents[0];
+ const profile = agent.profiles[0];
+ const copyName = `${profile.name} Copy`;
+
+ try {
+ await testPage.goto("/settings/agents");
+
+ // No document-level horizontal overflow on the list page.
+ await expect
+ .poll(
+ async () =>
+ testPage.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth),
+ { timeout: 15_000 },
+ )
+ .toBe(true);
+
+ const row = testPage.getByTestId("agent-profile-row").filter({ hasText: profile.name });
+ await expect(row).toBeVisible({ timeout: 15_000 });
+ // The row's actions trigger exposes a touch-sized hitbox (>= 44px).
+ // Poll for the box: layout can settle a frame after visibility.
+ const trigger = row.getByRole("button", { name: "Profile actions" });
+ await expect
+ .poll(
+ async () => {
+ const box = await trigger.boundingBox();
+ if (!box) return null;
+ return Math.min(box.width, box.height);
+ },
+ { timeout: 10_000 },
+ )
+ .toBeGreaterThanOrEqual(44);
+ await trigger.tap();
+ const duplicate = testPage.getByTestId(`duplicate-profile-${profile.id}`);
+ await expect(duplicate).toBeVisible({ timeout: 15_000 });
+ await duplicate.tap();
+
+ // The copy appears as its own row without a reload.
+ await expect
+ .poll(
+ async () => {
+ const { agents: after } = await apiClient.listAgents();
+ const afterAgent = after.find((a) => a.id === agent.id);
+ const copy = afterAgent?.profiles.find((p) => p.name === copyName);
+ return copy?.id;
+ },
+ { timeout: 15_000 },
+ )
+ .toBeTruthy();
+
+ await expect(testPage.getByRole("link", { name: copyName, exact: true })).toBeVisible({
+ timeout: 15_000,
+ });
+ } finally {
+ const { agents: cleanupAgents } = await apiClient.listAgents().catch(() => ({
+ agents: [] as typeof agents,
+ }));
+ const cleanupAgent = cleanupAgents.find((a) => a.id === agent.id);
+ const copy = cleanupAgent?.profiles.find((p) => p.name === copyName);
+ if (copy) {
+ await apiClient.deleteAgentProfile(copy.id, true).catch(() => {});
+ }
+ }
+ });
+});
diff --git a/apps/web/hooks/domains/settings/use-profile-duplicate.test.ts b/apps/web/hooks/domains/settings/use-profile-duplicate.test.ts
new file mode 100644
index 0000000000..22032045c2
--- /dev/null
+++ b/apps/web/hooks/domains/settings/use-profile-duplicate.test.ts
@@ -0,0 +1,189 @@
+import { describe, expect, it, vi } from "vitest";
+import type { Agent, AgentProfile } from "@/lib/types/http";
+import type { AgentProfileOption } from "@/lib/state/slices/settings/types";
+import { applyProfileDuplicated } from "./use-profile-duplicate";
+
+vi.mock("@/app/actions/agents", () => ({ duplicateAgentProfileAction: vi.fn() }));
+vi.mock("@/components/state-provider", () => ({ useAppStoreApi: vi.fn() }));
+vi.mock("@/components/toast-provider", () => ({ useToast: vi.fn() }));
+
+const COPY_NAME = "Default Copy";
+const OLD_REVISION = "2026-08-11T21:00:00Z";
+const NEW_REVISION = "2026-08-11T22:00:00Z";
+
+/** Builds an AgentProfile fixture with an optional updatedAt. */
+function profile(id: string, agentId: string, name = id, updatedAt = ""): AgentProfile {
+ return {
+ id,
+ agentId,
+ name,
+ agentDisplayName: "Test Agent",
+ model: "",
+ allowIndexing: false,
+ autoApprove: false,
+ cliFlags: [],
+ cliPassthrough: false,
+ enabled: true,
+ createdAt: "",
+ updatedAt,
+ } as unknown as AgentProfile;
+}
+
+/** Builds an Agent fixture carrying the given profiles. */
+function agent(id: string, ...profiles: AgentProfile[]): Agent {
+ return { id, name: id, profiles } as unknown as Agent;
+}
+
+/** Builds an AgentProfileOption fixture with an optional updatedAt. */
+function option(id: string, updatedAt = ""): AgentProfileOption {
+ return {
+ id,
+ label: id,
+ agent_id: "a1",
+ agent_name: "a1",
+ cli_passthrough: false,
+ updatedAt,
+ };
+}
+
+/** Builds the settings slice state the duplicate merge operates on. */
+function stateWith(agents: Agent[], options: AgentProfileOption[]) {
+ return {
+ settingsAgents: { items: agents, version: 0 },
+ agentProfiles: { items: options, version: 0 },
+ };
+}
+
+describe("applyProfileDuplicated", () => {
+ it("appends the copy to the owning agent and surfaces it as an option", () => {
+ const source = profile("p1", "a1", "Default");
+ const copy = profile("p2", "a1", COPY_NAME);
+ const initial = stateWith([agent("a1", source)], []);
+
+ const next = applyProfileDuplicated(initial, agent("a1"), copy);
+
+ const profiles = next.settingsAgents.items.find((a) => a.id === "a1")?.profiles ?? [];
+ expect(profiles.map((p) => p.id)).toEqual(["p1", "p2"]);
+ // Every profile (source + copy) is rebuilt into the options slice.
+ expect(next.agentProfiles.items.map((o) => o.id)).toEqual(["p1", "p2"]);
+ });
+
+ it("dedupes by id so a WS-delivered copy is not double-inserted", () => {
+ const source = profile("p1", "a1");
+ const copy = profile("p2", "a1", COPY_NAME);
+ // The WS agent.profile.created handler delivered the copy first.
+ const initial = stateWith([agent("a1", source)], [option("p2")]);
+
+ const next = applyProfileDuplicated(initial, agent("a1"), copy);
+
+ const profiles = next.settingsAgents.items.find((a) => a.id === "a1")?.profiles ?? [];
+ expect(profiles.filter((p) => p.id === "p2")).toHaveLength(1);
+ expect(next.agentProfiles.items.filter((o) => o.id === "p2")).toHaveLength(1);
+ });
+
+ it("keeps the copy visible when the owning agent left the store mid-request", () => {
+ const copy = profile("p2", "a1", COPY_NAME);
+ const initial = stateWith([], []);
+
+ const next = applyProfileDuplicated(initial, agent("a1"), copy);
+
+ // settingsAgents is unchanged (no agent to attach to), but the copy must
+ // still surface in the agentProfiles slice instead of being dropped.
+ expect(next.settingsAgents.items).toEqual([]);
+ expect(next.agentProfiles.items.map((o) => o.id)).toEqual(["p2"]);
+ });
+
+ it("does not erase a WS-delivered copy and refreshes it with agent metadata", () => {
+ const copy = profile("p2", "a1", COPY_NAME);
+ // WS delivered the option first (with a stub agent_name) while the
+ // owning agent is absent; the merge must replace it with the full-agent
+ // option rather than keep the empty-name stub.
+ const initial = stateWith([], [option("p2")]);
+
+ const next = applyProfileDuplicated(initial, agent("a1"), copy);
+
+ const options = next.agentProfiles.items.filter((o) => o.id === "p2");
+ expect(options).toHaveLength(1);
+ expect(options[0].agent_name).toBe("a1");
+ });
+
+ it("keeps a newer WS-delivered orphan option over a stale duplicate response", () => {
+ // Owner absent; WS delivered a NEWER version of the copy than this
+ // delayed HTTP response. The merge must not regress it to the stale one.
+ const staleCreated = profile("p2", "a1", COPY_NAME, OLD_REVISION);
+ const newerOrphan = option("p2", NEW_REVISION);
+ const initial = stateWith([], [newerOrphan]);
+
+ const next = applyProfileDuplicated(initial, agent("a1"), staleCreated);
+
+ const options = next.agentProfiles.items.filter((o) => o.id === "p2");
+ expect(options).toHaveLength(1);
+ // The preserved option keeps the newer revision (label from the option).
+ expect(options[0].label).toBe("p2");
+ expect(options[0].updatedAt).toBe(NEW_REVISION);
+ });
+
+ it("keeps a newer WS-delivered option over a stale rebuilt one when the owner is present", () => {
+ // The option was updated by WS (enabled=false, newer revision) while the
+ // settingsAgents profile is stale. The merge must not regress it to the
+ // rebuilt (older) version — a disabled profile must stay hidden.
+ const staleProfile = profile("p1", "a1", "Default", OLD_REVISION);
+ const copy = profile("p2", "a1", COPY_NAME, OLD_REVISION);
+ const newerCopyOption = { ...option("p2", NEW_REVISION), enabled: false };
+ const initial = stateWith([agent("a1", staleProfile)], [newerCopyOption]);
+
+ const next = applyProfileDuplicated(initial, agent("a1"), copy);
+
+ const options = next.agentProfiles.items.filter((o) => o.id === "p2");
+ expect(options).toHaveLength(1);
+ expect(options[0].enabled).toBe(false);
+ expect(options[0].updatedAt).toBe(NEW_REVISION);
+ });
+
+ it("orders revisions by instant, not lexically, for offset timestamps", () => {
+ // "2026-08-11T23:30:00+02:00" is 21:30 UTC — OLDER than 22:00Z, but
+ // lexically larger. A string compare would keep the stale duplicate
+ // response over the newer WS-delivered option.
+ const staleCreated = profile("p2", "a1", COPY_NAME, "2026-08-11T23:30:00+02:00");
+ const newerOrphan = option("p2", "2026-08-11T22:00:00Z");
+ const initial = stateWith([], [newerOrphan]);
+
+ const next = applyProfileDuplicated(initial, agent("a1"), staleCreated);
+
+ const options = next.agentProfiles.items.filter((o) => o.id === "p2");
+ expect(options).toHaveLength(1);
+ expect(options[0].updatedAt).toBe("2026-08-11T22:00:00Z");
+ });
+
+ it("keeps a newer WS-delivered version instead of the stale duplicate response", () => {
+ // Another tab edited the copy after creation: agent.profile.updated
+ // delivered the newer version before this delayed duplicate response.
+ const newer = profile("p2", "a1", "Default Copy (edited)", NEW_REVISION);
+ const staleCreated = profile("p2", "a1", COPY_NAME, OLD_REVISION);
+ const source = profile("p1", "a1");
+ const initial = stateWith([agent("a1", source, newer)], [option("p1"), option("p2")]);
+
+ const next = applyProfileDuplicated(initial, agent("a1"), staleCreated);
+
+ const stored = next.settingsAgents.items.find((a) => a.id === "a1")?.profiles ?? [];
+ expect(stored.find((p) => p.id === "p2")?.name).toBe("Default Copy (edited)");
+ expect(next.agentProfiles.items.find((o) => o.id === "p2")?.label).toContain(
+ "Default Copy (edited)",
+ );
+ });
+
+ it("preserves WS-delivered orphan options for agents absent from the store", () => {
+ // p-orphan was delivered by WS for an agent not present in settingsAgents;
+ // duplicating a profile of a DIFFERENT agent must not wipe it.
+ const source = profile("p1", "a2");
+ const copy = profile("p2", "a2", COPY_NAME);
+ const initial = stateWith([agent("a2", source)], [option("p-orphan")]);
+
+ const next = applyProfileDuplicated(initial, agent("a2"), copy);
+
+ const ids = next.agentProfiles.items.map((o) => o.id);
+ expect(ids).toContain("p-orphan");
+ expect(ids).toContain("p2");
+ expect(ids.filter((id) => id === "p2")).toHaveLength(1);
+ });
+});
diff --git a/apps/web/hooks/domains/settings/use-profile-duplicate.ts b/apps/web/hooks/domains/settings/use-profile-duplicate.ts
new file mode 100644
index 0000000000..7187cce319
--- /dev/null
+++ b/apps/web/hooks/domains/settings/use-profile-duplicate.ts
@@ -0,0 +1,116 @@
+"use client";
+
+import { useCallback, useRef } from "react";
+import { duplicateAgentProfileAction } from "@/app/actions/agents";
+import { useAppStoreApi } from "@/components/state-provider";
+import { useToast } from "@/components/toast-provider";
+import { t as translate } from "@/lib/i18n";
+import {
+ compareTimestamps,
+ mergeOptionsByNewest,
+ toAgentProfileOption,
+ type AgentProfileOption,
+} from "@/lib/state/slices/settings/types";
+import type { AppState } from "@/lib/state/store";
+import type { Agent, AgentProfile } from "@/lib/types/http";
+
+type ProfileState = Pick;
+
+/**
+ * Merge one duplicated profile into the latest store state. Dedupes by ID so
+ * a concurrent `agent.profile.created` WS delivery cannot double-insert the
+ * copy into either slice.
+ *
+ * The options slice is rebuilt from `settingsAgents` by ID on top of the
+ * existing options: options the rebuild does not represent (e.g. profiles the
+ * WS handler delivered for agents temporarily absent from `settingsAgents`)
+ * are preserved, and the new copy always appears exactly once — via the
+ * rebuild when its owning agent is present, otherwise via a stub so it is
+ * never dropped.
+ *
+ * A stale duplicate HTTP response never clobbers a newer profile: when the
+ * copy already exists in the store (e.g. another tab edited it and
+ * `agent.profile.updated` arrived first), the newer `updatedAt` wins.
+ */
+export function applyProfileDuplicated(
+ state: ProfileState,
+ agent: Agent,
+ created: AgentProfile,
+): ProfileState {
+ const nextAgents = state.settingsAgents.items.map((item: Agent) =>
+ item.id === agent.id
+ ? (() => {
+ const existing = item.profiles.find((p) => p.id === created.id);
+ const latest =
+ existing && compareTimestamps(existing.updatedAt, created.updatedAt) > 0
+ ? existing
+ : created;
+ return {
+ ...item,
+ profiles: [...item.profiles.filter((p) => p.id !== created.id), latest],
+ };
+ })()
+ : item,
+ );
+
+ const rebuiltOptions = nextAgents.flatMap((item) =>
+ item.profiles.map((profile) => toAgentProfileOption(item, profile)),
+ );
+ const merged = mergeOptionsByNewest(state.agentProfiles.items, rebuiltOptions);
+ // The copy must appear exactly once with the known agent metadata: append
+ // it when absent, replace an OLDER existing option (e.g. a WS stub) with
+ // it, and keep a NEWER WS-delivered option untouched.
+ const copyOption = toAgentProfileOption({ id: agent.id, name: agent.name }, created);
+ const existingCopy = merged.find((option) => option.id === created.id);
+ let agentProfilesItems: AgentProfileOption[];
+ if (!existingCopy) {
+ agentProfilesItems = [...merged, copyOption];
+ } else if (compareTimestamps(existingCopy.updatedAt, created.updatedAt) > 0) {
+ agentProfilesItems = merged; // keep the newer WS-delivered option
+ } else {
+ agentProfilesItems = merged.map((option) => (option.id === created.id ? copyOption : option));
+ }
+
+ return {
+ settingsAgents: { ...state.settingsAgents, items: nextAgents },
+ agentProfiles: { ...state.agentProfiles, items: agentProfilesItems },
+ };
+}
+
+/**
+ * Duplicate a profile from the /settings/agents profile list. The returned
+ * copy is merged into the store atomically so the new row appears without
+ * waiting on the WebSocket round-trip.
+ */
+export function useProfileDuplicate() {
+ const { toast } = useToast();
+ const storeApi = useAppStoreApi();
+ // Per-profile in-flight guard: the row button stays clickable while the
+ // request runs, so a double-click must not issue two copies.
+ const pendingRef = useRef(new Set());
+
+ return useCallback(
+ async (agent: Agent, profile: AgentProfile) => {
+ if (pendingRef.current.has(profile.id)) return;
+ pendingRef.current.add(profile.id);
+ try {
+ const created = await duplicateAgentProfileAction(profile.id);
+ storeApi.setState((state) => applyProfileDuplicated(state, agent, created));
+ toast({
+ title: translate("agents:duplicateProfileSuccess"),
+ description: created.name,
+ variant: "success",
+ });
+ } catch (error) {
+ toast({
+ title: translate("agents:failedToDuplicateProfile"),
+ description: error instanceof Error ? error.message : translate("agents:requestFailed"),
+ variant: "error",
+ });
+ } finally {
+ pendingRef.current.delete(profile.id);
+ }
+ },
+ [storeApi, toast],
+ );
+}
diff --git a/apps/web/lib/routing/client-router.test.ts b/apps/web/lib/routing/client-router.test.ts
index 46ba6670de..afce375693 100644
--- a/apps/web/lib/routing/client-router.test.ts
+++ b/apps/web/lib/routing/client-router.test.ts
@@ -3,10 +3,17 @@ import { afterEach, describe, expect, it, vi } from "vitest";
import { clearNavigationBlockerForTests, setNavigationBlocker } from "./navigation-guard";
import { useParams, usePathname, useRouter, useSearchParams } from "./client-router";
+const NAV_POSITION_KEY = "__kandevNavigationPosition";
+
function setLocation(path: string) {
window.history.replaceState({}, "", path);
}
+/** Simulates a history popstate at the given location for router tests. */
+function popStateAt(position: number) {
+ window.dispatchEvent(new PopStateEvent("popstate", { state: { [NAV_POSITION_KEY]: position } }));
+}
+
afterEach(() => {
clearNavigationBlockerForTests();
vi.unstubAllGlobals();
@@ -61,33 +68,82 @@ describe("client router adapter", () => {
expect(reload).toHaveBeenCalledOnce();
});
- it("guards imperative push and history navigation", () => {
- setLocation("/settings/general/appearance");
- const attempts: Array<() => void> = [];
- setNavigationBlocker((intent) => attempts.push(intent.proceed));
- const go = vi.spyOn(window.history, "go").mockImplementation(() => undefined);
- const back = vi.spyOn(window.history, "back").mockImplementation(() => {
- window.dispatchEvent(
- new PopStateEvent("popstate", {
- state: { __kandevNavigationPosition: 0 },
- }),
- );
+ describe("navigation guard", () => {
+ function setupGuardedRouter() {
+ setLocation("/settings/general/appearance");
+ const intents: Array<{ proceed: () => void; cancel: () => void }> = [];
+ setNavigationBlocker((intent) => intents.push(intent));
+ const go = vi.spyOn(window.history, "go").mockImplementation(() => undefined);
+ const back = vi.spyOn(window.history, "back").mockImplementation(() => popStateAt(0));
+ const { result } = renderHook(() => useRouter());
+ return { result, intents, go, back };
+ }
+
+ it("guards imperative push and history navigation", () => {
+ const { result, intents, go, back } = setupGuardedRouter();
+
+ act(() => result.current.push("/tasks"));
+ expect(window.location.pathname).toBe("/settings/general/appearance");
+ act(() => intents.shift()?.proceed());
+ expect(window.location.pathname).toBe("/tasks");
+
+ act(() => result.current.back());
+ expect(back).toHaveBeenCalledOnce();
+ expect(intents).toHaveLength(1);
+ act(() => intents.shift()?.proceed());
+ window.dispatchEvent(new PopStateEvent("popstate", { state: window.history.state }));
+ window.dispatchEvent(new PopStateEvent("popstate", { state: null }));
+ expect(intents).toHaveLength(0);
+ expect(go).toHaveBeenCalledTimes(2);
});
- const { result } = renderHook(() => useRouter());
- act(() => result.current.push("/tasks"));
- expect(window.location.pathname).toBe("/settings/general/appearance");
+ it("consumes a cancelled blocked pop's restoration popstate when no newer navigation superseded it", () => {
+ const { result, intents, go } = setupGuardedRouter();
- act(() => attempts.shift()?.());
- expect(window.location.pathname).toBe("/tasks");
+ act(() => result.current.push("/tasks"));
+ act(() => intents.pop()?.proceed()); // allow the push -> currentPosition 1
+ act(() => result.current.back()); // blocked pop to position 0; restoration to 1 pending
+ expect(intents).toHaveLength(1);
- act(() => result.current.back());
- expect(back).toHaveBeenCalledOnce();
- expect(attempts).toHaveLength(1);
- act(() => attempts.shift()?.());
- window.dispatchEvent(new PopStateEvent("popstate", { state: window.history.state }));
- window.dispatchEvent(new PopStateEvent("popstate", { state: null }));
- expect(attempts).toHaveLength(0);
- expect(go).toHaveBeenCalledTimes(2);
+ act(() => {
+ intents[0].cancel(); // cancel without any newer navigation
+ });
+
+ // The in-flight restoration popstate for the blocked entry is consumed
+ // without touching currentPosition (still 1).
+ act(() => popStateAt(1));
+
+ // A later real back to position 0 is a fresh guarded pop (delta -1),
+ // not a silent acceptance.
+ act(() => popStateAt(0));
+ expect(intents).toHaveLength(2);
+ expect(go).toHaveBeenCalled();
+ });
+
+ it("forgets a cancelled blocked pop once a newer navigation supersedes it", () => {
+ const { result, intents, go } = setupGuardedRouter();
+
+ act(() => result.current.push("/tasks"));
+ act(() => intents.pop()?.proceed()); // allow the push -> currentPosition 1
+ act(() => result.current.back()); // blocked pop to position 0
+ expect(intents).toHaveLength(1);
+
+ // Duplicate-like flow: cancel, then push a new route. The push
+ // supersedes the pending traversal, so the browser may never emit its
+ // popstate; the guard must forget the cancelled restoration instead of
+ // arming a stale position that could eat a later navigation.
+ act(() => {
+ intents[0].cancel();
+ result.current.push("/settings/agents/mock-agent/profiles/copy-1");
+ intents.pop()?.proceed(); // allow the duplicate push -> currentPosition 2
+ });
+
+ // A popstate to the blocked entry's position arrives late (or is a
+ // real back): it must be treated as a fresh guarded pop (delta -1 from
+ // position 2), not consumed as stale.
+ act(() => popStateAt(1));
+ expect(intents).toHaveLength(2);
+ expect(go).toHaveBeenCalled();
+ });
});
});
diff --git a/apps/web/lib/routing/navigation-guard.ts b/apps/web/lib/routing/navigation-guard.ts
index 3ed29f68e4..fe0916e469 100644
--- a/apps/web/lib/routing/navigation-guard.ts
+++ b/apps/web/lib/routing/navigation-guard.ts
@@ -13,6 +13,11 @@ let popstateInstalled = false;
let historyMutationsTracked = false;
let allowedPop = false;
let restoringPop = false;
+// Position of a blocked-pop restoration whose traversal is still in flight
+// when the intent was cancelled. The delayed popstate for that position must
+// be consumed without touching currentPosition, so a newer navigation (e.g. a
+// push performed right after cancel) is not clobbered.
+let canceledRestorationPosition: number | null = null;
type BlockedPop = {
delta: number;
@@ -96,6 +101,7 @@ export function clearNavigationBlockerForTests(): void {
allowedPop = false;
restoringPop = false;
blockedPop = null;
+ canceledRestorationPosition = null;
}
function ensureHistoryTracking(): void {
@@ -132,6 +138,14 @@ function handlePopState(event: PopStateEvent): void {
return;
}
+ if (targetPosition === canceledRestorationPosition) {
+ // Popstate for a blocked-pop restoration whose intent was cancelled: a
+ // newer navigation may have happened since, so consume it without
+ // updating currentPosition.
+ canceledRestorationPosition = null;
+ return;
+ }
+
if (allowedPop) {
allowedPop = false;
currentPosition = targetPosition;
@@ -172,6 +186,7 @@ function blockPop(event: PopStateEvent, delta: number, restorePosition: number):
};
blockedPop = pending;
restoringPop = true;
+ canceledRestorationPosition = null; // a new block supersedes any stale one
window.history.go(-delta);
blocker({
@@ -189,11 +204,16 @@ function trackNativeHistoryMutations(): void {
const position = readPosition(state) ?? (currentPosition ?? 0) + 1;
pushState(withPosition(state, position), title, url);
currentPosition = position;
+ // A new navigation supersedes any blocked-pop traversal still in flight;
+ // without this the cancelled restoration position could eat a later
+ // legitimate popstate to the same position.
+ canceledRestorationPosition = null;
};
window.history.replaceState = (state, title, url) => {
const position = readPosition(state) ?? currentPosition ?? 0;
replaceState(withPosition(state, position), title, url);
currentPosition = position;
+ canceledRestorationPosition = null;
};
}
@@ -211,7 +231,14 @@ function proceedBlockedPop(pending: BlockedPop): void {
function cancelBlockedPop(pending: BlockedPop): void {
if (blockedPop !== pending) return;
pending.canceled = true;
- if (pending.restored) blockedPop = null;
+ if (!pending.restored) {
+ // The history.go(-delta) restoration is still in flight. Its popstate
+ // must not overwrite a newer currentPosition (e.g. a push performed
+ // right after cancel), so consume that exact position when it arrives.
+ canceledRestorationPosition = pending.restorePosition;
+ restoringPop = false;
+ }
+ blockedPop = null;
}
function finishPopRestoration(): void {
diff --git a/apps/web/lib/state/slices/settings/types.ts b/apps/web/lib/state/slices/settings/types.ts
index 344ca2cedd..ed85662942 100644
--- a/apps/web/lib/state/slices/settings/types.ts
+++ b/apps/web/lib/state/slices/settings/types.ts
@@ -60,6 +60,9 @@ export type AgentProfileOption = {
/** Legacy automatic-fallback opt-in. */
auto_fallback?: boolean;
workspace_id?: string;
+ /** Persisted profile revision (RFC3339 updated_at), used to prefer newer
+ * WS-delivered options over a stale in-flight response. */
+ updatedAt?: string;
/**
* False hides the profile from task/session creation pickers. Existing
* sessions keep their labels and the profile stays editable in settings.
@@ -79,10 +82,53 @@ export function isSelectableAgentProfile(profile: Pick();
+ for (const option of previous) {
+ byId.set(option.id, option);
+ }
+ for (const option of rebuilt) {
+ const existing = byId.get(option.id);
+ if (!existing || compareTimestamps(option.updatedAt, existing.updatedAt) >= 0) {
+ byId.set(option.id, option);
+ }
+ }
+ return [...byId.values()];
+}
+
/** Single source of truth for mapping an API Agent+Profile to a store AgentProfileOption. */
export function toAgentProfileOption(
agent: Pick,
profile: Pick & {
+ updatedAt?: string;
cliPassthrough?: boolean;
model?: string;
fallbackModel?: string;
@@ -100,6 +146,7 @@ export function toAgentProfileOption(
fallback_model: profile.fallbackModel ?? undefined,
auto_fallback: profile.autoFallback ?? undefined,
workspace_id: profile.workspaceId,
+ updatedAt: profile.updatedAt,
enabled: profile.enabled ?? true,
capability_status: agent.capability_status,
capability_error: agent.capability_error,
diff --git a/apps/web/lib/ws/handlers/agents.test.ts b/apps/web/lib/ws/handlers/agents.test.ts
index 6b41d20aca..8ea7413010 100644
--- a/apps/web/lib/ws/handlers/agents.test.ts
+++ b/apps/web/lib/ws/handlers/agents.test.ts
@@ -13,23 +13,62 @@ function makeStore() {
) as unknown as StoreApi;
}
-function message(action: string, payload: unknown) {
+const TIMESTAMP = "2026-07-26T10:00:00Z";
+const NOTIFICATION_TYPE = "notification";
+const PROFILE_CREATED = "agent.profile.created";
+const PROFILE_UPDATED = "agent.profile.updated";
+const PROFILE_DELETED = "agent.profile.deleted";
+
+/** Builds a WS notification message fixture with the given action, payload, and timestamp. */
+function message(action: string, payload: unknown, timestamp = TIMESTAMP) {
return {
id: `message-${action}`,
- type: "notification",
+ type: NOTIFICATION_TYPE,
action,
- timestamp: "2026-07-26T10:00:00Z",
+ timestamp,
payload,
};
}
-describe("agent runtime update websocket handlers", () => {
+/** Builds a kanban profile payload fixture, overridable per test. */
+function profilePayload(overrides: Record = {}) {
+ return {
+ id: "p1",
+ agent_id: "agent-1",
+ name: "Default",
+ model: "mock-fast",
+ enabled: true,
+ created_at: TIMESTAMP,
+ updated_at: TIMESTAMP,
+ ...overrides,
+ };
+}
+
+/** Builds an office-scoped profile payload fixture (workspace_id set). */
+function officeProfilePayload() {
+ return {
+ id: "profile-office",
+ agent_id: "agent-1",
+ name: "Office Agent",
+ workspace_id: "ws-1",
+ enabled: true,
+ created_at: TIMESTAMP,
+ updated_at: TIMESTAMP,
+ };
+}
+
+/** Registers the agents WS handlers and returns them keyed by action. */
+function handlersFor(store: ReturnType) {
+ return registerAgentsHandlers(store) as unknown as Record<
+ string,
+ (event: ReturnType) => void
+ >;
+}
+
+describe("agent update job websocket handlers", () => {
it("upserts update snapshots and appends each output chunk once", () => {
const store = makeStore();
- const handlers = registerAgentsHandlers(store) as unknown as Record<
- string,
- (event: ReturnType) => void
- >;
+ const handlers = handlersFor(store);
const snapshot = {
job_id: "update-1",
agent_name: "claude-acp",
@@ -64,3 +103,161 @@ describe("agent runtime update websocket handlers", () => {
).toMatchObject({ status: "succeeded", output: "downloaded\n" });
});
});
+
+describe("agent profile events", () => {
+ it("ignores office-scoped profile events so they never leak into global settings", () => {
+ const store = makeStore();
+ const handlers = handlersFor(store);
+ // The backend wraps the profile under { profile: ... } in the event.
+ const payload = { profile: officeProfilePayload() };
+
+ handlers[PROFILE_CREATED](message(PROFILE_CREATED, payload));
+ handlers[PROFILE_UPDATED](message(PROFILE_UPDATED, payload));
+
+ const state = store.getState();
+ expect(state.agentProfiles.items).toHaveLength(0);
+ expect(state.settingsAgents.items).toHaveLength(0);
+ });
+
+ it("does not let a delayed profile event overwrite newer stored state", () => {
+ const store = makeStore();
+ const handlers = handlersFor(store);
+ const newer = profilePayload({ model: "new-model", updated_at: "2026-07-26T11:00:00Z" });
+ handlers[PROFILE_CREATED](message(PROFILE_CREATED, { profile: newer }, "2026-07-26T11:05:00Z"));
+ // A delayed older event (e.g. a replayed duplicate response) must not
+ // regress the newer revision.
+ const older = profilePayload({ model: "stale-model", updated_at: "2026-07-26T09:00:00Z" });
+ handlers[PROFILE_UPDATED](message(PROFILE_UPDATED, { profile: older }, "2026-07-26T11:04:00Z"));
+
+ const stored = store.getState().agentProfiles.items[0];
+ expect(stored?.model).toBe("new-model");
+ });
+
+ it("does not resurrect a deleted profile from a delayed create event", () => {
+ const store = makeStore();
+ const handlers = handlersFor(store);
+
+ handlers[PROFILE_CREATED](
+ message(PROFILE_CREATED, { profile: profilePayload() }, "2026-07-26T10:00:00Z"),
+ );
+ expect(store.getState().agentProfiles.items).toHaveLength(1);
+
+ handlers[PROFILE_DELETED](
+ message(PROFILE_DELETED, { profile: profilePayload() }, "2026-07-26T12:00:00Z"),
+ );
+ expect(store.getState().agentProfiles.items).toHaveLength(0);
+
+ // A create event produced BEFORE the deletion is stale: no resurrection.
+ handlers[PROFILE_CREATED](
+ message(PROFILE_CREATED, { profile: profilePayload() }, "2026-07-26T11:00:00Z"),
+ );
+ expect(store.getState().agentProfiles.items).toHaveLength(0);
+
+ // A genuinely newer create (after the deletion) wins and clears the
+ // tombstone.
+ handlers[PROFILE_CREATED](
+ message(
+ "agent.profile.created",
+ { profile: profilePayload({ updated_at: "2026-07-26T13:00:00Z" }) },
+ "2026-07-26T13:00:00Z",
+ ),
+ );
+ expect(store.getState().agentProfiles.items).toHaveLength(1);
+ });
+
+ it("ignores office-scoped delete events", () => {
+ const store = makeStore();
+ const handlers = handlersFor(store);
+ handlers[PROFILE_DELETED](message(PROFILE_DELETED, { profile: officeProfilePayload() }));
+
+ expect(store.getState().agentProfiles.items).toHaveLength(0);
+ expect(store.getState().settingsAgents.items).toHaveLength(0);
+ });
+});
+
+describe("agent profile event ordering", () => {
+ it("ignores a stale delete event when a newer revision already exists", () => {
+ const store = makeStore();
+ const handlers = handlersFor(store);
+ const current = profilePayload({
+ id: "p-stale",
+ model: "new-model",
+ updated_at: "2026-07-26T11:00:00Z",
+ });
+ handlers[PROFILE_CREATED](
+ message(PROFILE_CREATED, { profile: current }, "2026-07-26T11:05:00Z"),
+ );
+ expect(store.getState().agentProfiles.items).toHaveLength(1);
+
+ // A delayed delete carrying an OLDER snapshot than the stored revision
+ // must not remove the current profile.
+ const staleDelete = profilePayload({
+ id: "p-stale",
+ model: "new-model",
+ updated_at: TIMESTAMP,
+ });
+ handlers[PROFILE_DELETED](
+ message(PROFILE_DELETED, { profile: staleDelete }, "2026-07-26T11:02:00Z"),
+ );
+
+ const state = store.getState();
+ expect(state.agentProfiles.items).toHaveLength(1);
+ expect(state.agentProfiles.items[0]?.model).toBe("new-model");
+ // A genuinely newer delete (after the stored revision) still applies.
+ handlers[PROFILE_DELETED](
+ message(PROFILE_DELETED, { profile: current }, "2026-07-26T12:00:00Z"),
+ );
+ expect(store.getState().agentProfiles.items).toHaveLength(0);
+ });
+
+ it("orders revisions by instant, not lexically, for fractional-second timestamps", () => {
+ const store = makeStore();
+ const handlers = handlersFor(store);
+ // Lexically "…10:00:00Z" sorts AFTER "…10:00:00.100Z", so a naive string
+ // compare would treat the whole-second revision as newer and regress it.
+ const fractional = profilePayload({
+ id: "p-frac",
+ model: "fractional-model",
+ updated_at: "2026-07-26T10:00:00.100Z",
+ });
+ handlers[PROFILE_CREATED](
+ message(PROFILE_CREATED, { profile: fractional }, "2026-07-26T10:00:00.100Z"),
+ );
+
+ const wholeSecond = profilePayload({
+ id: "p-frac",
+ model: "whole-second-model",
+ updated_at: TIMESTAMP,
+ });
+ handlers[PROFILE_UPDATED](message(PROFILE_UPDATED, { profile: wholeSecond }));
+
+ expect(store.getState().agentProfiles.items[0]?.model).toBe("fractional-model");
+ });
+
+ it("keeps the tombstone ordered by instant for fractional-second deletes", () => {
+ const store = makeStore();
+ const handlers = handlersFor(store);
+ handlers[PROFILE_CREATED](
+ message(PROFILE_CREATED, { profile: profilePayload({ id: "p-tomb" }) }),
+ );
+ // Delete at a fractional second; the tombstone must beat a whole-second
+ // create produced before it.
+ handlers[PROFILE_DELETED](
+ message(
+ PROFILE_DELETED,
+ { profile: profilePayload({ id: "p-tomb" }) },
+ "2026-07-26T10:00:00.100Z",
+ ),
+ );
+ expect(store.getState().agentProfiles.items).toHaveLength(0);
+
+ handlers[PROFILE_CREATED](
+ message(
+ PROFILE_CREATED,
+ { profile: profilePayload({ id: "p-tomb" }) },
+ "2026-07-26T10:00:00.050Z",
+ ),
+ );
+ expect(store.getState().agentProfiles.items).toHaveLength(0);
+ });
+});
diff --git a/apps/web/lib/ws/handlers/agents.ts b/apps/web/lib/ws/handlers/agents.ts
index ee3876ed71..20b6d7f442 100644
--- a/apps/web/lib/ws/handlers/agents.ts
+++ b/apps/web/lib/ws/handlers/agents.ts
@@ -1,7 +1,7 @@
import type { StoreApi } from "zustand";
import type { AppState } from "@/lib/state/store";
import type { WsHandlers } from "@/lib/ws/handlers/types";
-import { toAgentProfileOption } from "@/lib/state/slices/settings/types";
+import { compareTimestamps, toAgentProfileOption } from "@/lib/state/slices/settings/types";
import { normalizeAgentProfile } from "@/lib/api/domains/agent-profile-normalize";
import type { AgentProfile } from "@/lib/types/agent-profile";
@@ -15,8 +15,78 @@ function getAgentId(raw: unknown): string {
return typeof value === "string" ? value : "";
}
-function handleProfileCreated(state: AppState, profile: unknown): Partial {
+/**
+ * Office-scoped profiles are owned by the office channels, never the kanban
+ * settings surface (the HTTP agent list hides them via filterGlobalProfiles).
+ * Defense in depth: ignore their events here so a stray broadcast cannot leak
+ * them into the global settings store and selectors.
+ */
+function isOfficeScoped(normalized: { workspaceId?: string }): boolean {
+ return Boolean(normalized.workspaceId);
+}
+
+/** Finds a profile in the settings agents list by id, across all agents. */
+function findExistingProfile(state: AppState, profileId: string): AgentProfile | undefined {
+ for (const item of state.settingsAgents.items) {
+ const found = item.profiles.find((p) => p.id === profileId);
+ if (found) return found;
+ }
+ return undefined;
+}
+
+// Deletion tombstones keyed by profile id -> deletion event timestamp, so a
+// delayed create/update event cannot resurrect a profile that was deleted
+// after the event was produced. Cleared when a genuinely newer create arrives.
+// Tombstones are keyed by UUID and profiles are never recreated under the same
+// ID, so the map is bounded by the number of profiles deleted in this session
+// (typically single digits to low dozens — no eviction needed).
+const deletionTombstones = new Map();
+
+/**
+ * A profile event is stale when the store already holds a newer revision of
+ * the profile or its option (e.g. a delayed duplicate response or a newer
+ * WebSocket update arrived first), or when the profile was deleted after the
+ * event was produced (tombstone). Events must never regress newer state.
+ * Missing event timestamps (never produced by the backend) are treated as
+ * not-stale so they cannot trip the guards.
+ */
+function isStaleProfileEvent(
+ state: AppState,
+ normalized: { id: string; updatedAt?: string },
+ eventTimestamp: string | undefined,
+): boolean {
+ const tombstone = deletionTombstones.get(normalized.id);
+ if (
+ tombstone !== undefined &&
+ eventTimestamp &&
+ compareTimestamps(tombstone, eventTimestamp) >= 0
+ ) {
+ return true;
+ }
+ const existingProfile = findExistingProfile(state, normalized.id);
+ if (existingProfile && compareTimestamps(existingProfile.updatedAt, normalized.updatedAt) > 0) {
+ return true;
+ }
+ const existingOption = state.agentProfiles.items.find((o) => o.id === normalized.id);
+ return Boolean(
+ existingOption && compareTimestamps(existingOption.updatedAt, normalized.updatedAt) > 0,
+ );
+}
+
+/**
+ * Applies an agent.profile.created event, skipping office-scoped or stale
+ * events (see isStaleProfileEvent) and clearing the deletion tombstone when a
+ * genuinely newer create arrives.
+ */
+function handleProfileCreated(
+ state: AppState,
+ profile: unknown,
+ eventTimestamp: string | undefined,
+): Partial {
const normalized = normalizeAgentProfile(profile);
+ if (isOfficeScoped(normalized)) return {};
+ if (isStaleProfileEvent(state, normalized, eventTimestamp)) return {};
+ deletionTombstones.delete(normalized.id); // a genuinely newer create wins
const agentId = getAgentId(profile);
const agent = state.settingsAgents.items.find((a) => a.id === agentId);
const agentStub = { id: agentId, name: agent?.name ?? "" };
@@ -41,8 +111,18 @@ function handleProfileCreated(state: AppState, profile: unknown): Partial {
+/**
+ * Applies an agent.profile.updated event, skipping office-scoped or stale
+ * events so a delayed update never regresses newer stored state.
+ */
+function handleProfileUpdated(
+ state: AppState,
+ profile: unknown,
+ eventTimestamp: string | undefined,
+): Partial {
const normalized = normalizeAgentProfile(profile);
+ if (isOfficeScoped(normalized)) return {};
+ if (isStaleProfileEvent(state, normalized, eventTimestamp)) return {};
const agentId = getAgentId(profile);
const agent = state.settingsAgents.items.find((a) => a.id === agentId);
const agentStub = { id: agentId, name: agent?.name ?? "" };
@@ -63,6 +143,41 @@ function handleProfileUpdated(state: AppState, profile: unknown): Partial {
+ const normalized = normalizeAgentProfile(profile);
+ if (isOfficeScoped(normalized)) return {};
+ if (isStaleProfileEvent(state, normalized, eventTimestamp)) return {};
+ if (eventTimestamp) deletionTombstones.set(normalized.id, eventTimestamp);
+ const agentId = getAgentId(profile);
+ const nextAgents = state.settingsAgents.items.map((item) =>
+ item.id === agentId
+ ? {
+ ...item,
+ profiles: item.profiles.filter((p) => p.id !== normalized.id),
+ }
+ : item,
+ );
+ return {
+ agentProfiles: {
+ ...state.agentProfiles,
+ items: state.agentProfiles.items.filter((p) => p.id !== normalized.id),
+ },
+ settingsAgents: { items: nextAgents },
+ };
+}
+
export function registerAgentsHandlers(store: StoreApi): WsHandlers {
return {
"agent.available.updated": (message) => {
@@ -118,35 +233,19 @@ export function registerAgentsHandlers(store: StoreApi): WsHandlers {
"agent.profile.created": (message) => {
store.setState((state) => ({
...state,
- ...handleProfileCreated(state, message.payload.profile),
+ ...handleProfileCreated(state, message.payload.profile, message.timestamp),
}));
},
"agent.profile.updated": (message) => {
store.setState((state) => ({
...state,
- ...handleProfileUpdated(state, message.payload.profile),
+ ...handleProfileUpdated(state, message.payload.profile, message.timestamp),
}));
},
"agent.profile.deleted": (message) => {
- const profile = message.payload.profile as Record;
- const profileId = profile.id as string;
- const agentId = getAgentId(profile);
store.setState((state) => ({
...state,
- agentProfiles: {
- ...state.agentProfiles,
- items: state.agentProfiles.items.filter((p) => p.id !== profileId),
- },
- settingsAgents: {
- items: state.settingsAgents.items.map((item) =>
- item.id === agentId
- ? {
- ...item,
- profiles: item.profiles.filter((p) => p.id !== profileId),
- }
- : item,
- ),
- },
+ ...handleProfileDeleted(state, message.payload.profile, message.timestamp),
}));
},
};
diff --git a/apps/web/src/locales/en/agents.json b/apps/web/src/locales/en/agents.json
index 5982f65095..fbd4940984 100644
--- a/apps/web/src/locales/en/agents.json
+++ b/apps/web/src/locales/en/agents.json
@@ -214,5 +214,10 @@
"watcherKindGithubIssue": "GitHub Issues",
"watcherKindGithubReview": "GitHub PR Reviews",
"watcherKindJira": "Jira",
- "watcherKindLinear": "Linear"
+ "watcherKindLinear": "Linear",
+ "duplicate": "Duplicate",
+ "duplicateProfileNamed": "Duplicate {{name}}",
+ "duplicateProfileSuccess": "Profile duplicated",
+ "duplicateSaveBlocked": "Settings are still saving. Try again in a moment.",
+ "failedToDuplicateProfile": "Failed to duplicate profile"
}
diff --git a/apps/web/src/locales/pseudo/agents.json b/apps/web/src/locales/pseudo/agents.json
index 2d66dbc77f..49b530d1ef 100644
--- a/apps/web/src/locales/pseudo/agents.json
+++ b/apps/web/src/locales/pseudo/agents.json
@@ -214,5 +214,10 @@
"watcherKindGithubIssue": "ĜĩţĤũƀ Ĩśśũēś",
"watcherKindGithubReview": "ĜĩţĤũƀ ƤŔ Ŕēvĩēŵś",
"watcherKindJira": "Ĵĩŕà",
- "watcherKindLinear": "Ĺĩńēàŕ"
+ "watcherKindLinear": "Ĺĩńēàŕ",
+ "duplicate": "Ďũƥĺĩćàţē",
+ "duplicateProfileNamed": "Ďũƥĺĩćàţē {{name}}",
+ "duplicateProfileSuccess": "Ƥŕōƒĩĺē ďũƥĺĩćàţēď",
+ "duplicateSaveBlocked": "Śēţţĩńĝś àŕē śţĩĺĺ śàvĩńĝ. Ţŕŷ àĝàĩń ĩń à ḿōḿēńţ.",
+ "failedToDuplicateProfile": "Ƒàĩĺēď ţō ďũƥĺĩćàţē ƥŕōƒĩĺē"
}
diff --git a/docs/plans/agent-profile-duplicate/plan.md b/docs/plans/agent-profile-duplicate/plan.md
new file mode 100644
index 0000000000..ed462391f6
--- /dev/null
+++ b/docs/plans/agent-profile-duplicate/plan.md
@@ -0,0 +1,256 @@
+---
+spec: docs/specs/agents/profile-duplicate.md
+created: 2026-08-11
+status: complete
+---
+
+# Implementation Plan: Agent Profile Duplicate
+
+## Overview
+
+Add a one-click "duplicate" for agent profiles on the settings agents surface
+(`/settings/agents` profile list and the per-profile settings page). A new
+interlock-protected endpoint `POST /api/v1/agent-profiles/:id/duplicate`
+copies the source profile's full configuration (model, mode, config options,
+CLI flags, env vars, launcher prefix, auto-approve flags, enabled state, MCP
+config row) into a fresh row named ` Copy`, broadcasts the existing
+`agent.profile.created` WS event, and returns the new profile DTO.
+
+## Backend
+
+### Controller: `DuplicateProfile`
+
+Add to `apps/backend/internal/agent/settings/controller/profile_crud.go`:
+
+- `type DuplicateProfileRequest struct { ID string }`.
+- `func (c *Controller) DuplicateProfile(ctx, req) (*dto.AgentProfileDTO, error)`:
+ 1. `repo.GetAgentProfile(ctx, req.ID)`; map the "agent profile not found"
+ error to `ErrAgentProfileNotFound` exactly like `DeleteProfile` does
+ (the sqlite store wraps `sql.ErrNoRows` in a message containing
+ "agent profile not found").
+ 2. Build a fresh `models.AgentProfile` copying every configuration field:
+ `AgentID`, `AgentDisplayName`, `Model`, `FallbackModel` (trimmed),
+ `AutoFallback`, `Mode`, `ConfigOptions` (through
+ `profileconfig.SanitizeConfigOptions` on a copied map),
+ `AllowIndexing`, `AutoApprove`, `CLIPassthrough`, `CLIFlags` (deep
+ copy of the slice), `EnvVars` (deep copy of the slice, keeping
+ `SecretID` refs), `CommandPrefix`, `UserModified: true`, and the office
+ enrichment configuration fields (`WorkspaceID`, `Role`, `Icon`,
+ `ReportsTo`, `SkillIDs`, `DesiredSkills`, `MaxConcurrentSessions`,
+ `CooldownSec`, `SkipIdleRuns`, `FailureThreshold` (copied pointer),
+ `ExecutorPreference`, `BudgetMonthlyCents`, `Settings`, `Permissions`).
+ Do NOT copy runtime state: `Status`, `PauseReason`, `LastRunFinishedAt`,
+ `ConsecutiveFailures`, `DeletedAt`, `MigratedFrom`, `CustomPrompt`,
+ `DangerouslySkipPermissions`.
+ 3. Name: `strings.TrimSpace(source.Name) + " Copy"`. The name is persisted
+ data, not UI copy (same convention as seeded executor/repository names),
+ so the suffix is a plain string in Go.
+ 4. Read the source's MCP config row when it has one (`repo
+ .GetAgentProfileMcpConfig(ctx, source.ID)`; tolerate `sql.ErrNoRows` /
+ nil); deep-copy `Servers` and `Meta` into a fresh
+ `models.AgentProfileMcpConfig` (ProfileID filled by the repo). A source
+ without a row leaves the copy without one — the default-config
+ semantics and boot `EnsureDefaultMcpConfig` cover MCP-supporting
+ agents.
+ 5. `repo.DuplicateAgentProfile(ctx, store.DuplicateAgentProfileInput{...})`
+ — NEW atomic repository operation (adversarial review round 1): one
+ transaction inserts the row with the caller-provided `Enabled` state
+ (NOT forced true like `CreateAgentProfile`, so a disabled source never
+ becomes briefly selectable) and upserts the MCP config row. A failure
+ rolls back, leaving no partial copy. Rollback makes each attempt
+ atomic, but the endpoint is not HTTP-idempotent: a retried request
+ creates another row (the UI guards against double-clicks). The store
+ assigns the fresh UUID and a single `CreatedAt`/`UpdatedAt` pair,
+ which the returned DTO reflects (no stale timestamp after a second
+ write).
+ 6. **Consistent snapshot (adversarial review round 5):** inside the
+ transaction the repository re-reads the source profile and MCP rows and
+ verifies their `updated_at` still match the revisions the copy was
+ built from (`ErrProfileChanged` / `ErrSourceProfileNotFound` otherwise);
+ WAL snapshot isolation aborts the write with a busy error if a
+ concurrent writer commits between the verification and the insert. The
+ controller retries (bounded, `maxDuplicateRetries = 2`) on
+ `ErrProfileChanged` / `ErrSourceProfileNotFound` / busy errors with a
+ fresh source read, so the copy always reflects one consistent snapshot.
+ 7. Return `toProfileDTO(clone)`.
+
+Env-var secret refs are copied verbatim; they were validated when the source
+was created/updated, so no re-validation is needed.
+
+### Handler + route
+
+In `apps/backend/internal/agent/settings/handlers/handlers.go`:
+
+- Register `api.POST("/agent-profiles/:id/duplicate", h.interlock,
+ h.httpDuplicateProfile)` next to the other `/agent-profiles/:id` routes.
+- `httpDuplicateProfile`: require `:id`, call
+ `controller.DuplicateProfile`, map `ErrAgentProfileNotFound` → 404, other
+ errors → 500; on success broadcast
+ `ws.ActionAgentProfileCreated` with `{"profile": resp}` (same payload
+ shape as `httpCreateProfile`) and return the DTO with 200.
+
+### Tests (backend)
+
+- Controller, new file
+ `apps/backend/internal/agent/settings/controller/profile_duplicate_test.go`
+ (using the existing `newTestController` + `newFakeStore`):
+ - full-config copy: source with model/fallback/mode/config options/CLI
+ flags/env vars/command prefix/auto-approve/cli-passthrough duplicates
+ with equal fields, new ID, `Default Copy` name, `user_modified` true;
+ - disabled source → disabled copy stored in the single atomic write (no
+ follow-up enabled flip, timestamps match the stored row);
+ - MCP config row copied to the new profile ID with equal enabled/servers/meta
+ (extend the shared `fakeStore` in `reconciler_test.go` with an
+ `mcpConfigs` map + working `GetAgentProfileMcpConfig` /
+ `UpsertAgentProfileMcpConfig` + `DuplicateAgentProfile`, additively —
+ other tests only observe the existing nil behaviour);
+ - store failure propagates and leaves no partial copy;
+ - unknown ID → `ErrAgentProfileNotFound`;
+ - empty source name (`""` → `" Copy"` is acceptable; source names are
+ non-empty by validation, but pin the suffix behaviour).
+- Store, new file `apps/backend/internal/agent/settings/store/sqlite_duplicate_test.go`:
+ sqlite `DuplicateAgentProfile` round-trip — fresh ID, full configuration
+ preserved, disabled copy stays disabled (not forced enabled), MCP row
+ copied, source untouched; no MCP row created when none passed.
+- Handler, `apps/backend/internal/agent/settings/handlers/interim_settings_interlock_test.go`:
+ add `{method: POST, path: "/api/v1/agent-profiles/profile-1/duplicate"}`
+ to the route list that must return 403 without the interlock token.
+- Handler test (mandatory, adversarial review round 9): an office-scoped
+ source (`WorkspaceID != ""`) returns 404 with zero broadcasts on any
+ channel — global or workspace-scoped — and the office profile is rejected
+ before MCP config is read or written. Also assert 404 mapping and the
+ `agent.profile.created` broadcast for kanban profiles, following
+ `agent_update_handlers_test.go`'s controller-stub pattern.
+
+## Frontend
+
+### API action
+
+In `apps/web/app/actions/agents.ts` add:
+
+```ts
+export async function duplicateAgentProfileAction(profileId: string): Promise {
+ const raw = await agentSettingsRequest(
+ `${apiBaseUrl}/api/v1/agent-profiles/${profileId}/duplicate`,
+ { method: "POST" },
+ );
+ return normalizeAgentProfile(raw);
+}
+```
+
+### List page: per-row Duplicate button
+
+- `apps/web/app/settings/agents/profile-list-item.tsx`: accept an
+ `onDuplicate: (profile: AgentProfile) => void` prop; render an icon-only
+ button (copy icon, e.g. `IconCopy` from `@tabler/icons-react`) outside the
+ link, next to the enabled switch, with `aria-label` / tooltip via
+ `t("agents:duplicateProfileNamed", { name: profile.name })` and
+ `data-testid={`duplicate-profile-${profile.id}`}`.
+- `apps/web/app/settings/agents/page.tsx`: thread `onDuplicate` through
+ `AgentProfilesSection`; add a `handleDuplicateProfile` wired like
+ `useProfileEnabledToggle` (POST via the action, then merge the returned
+ profile into `settingsAgents` + `agentProfiles` store slices atomically via
+ `useAppStoreApi().setState`, appending the new profile to its agent's
+ `profiles`; toast success/failure via `agents:duplicateProfileSuccess` /
+ `agents:failedToDuplicateProfile`). The `agent.profile.created` WS handler
+ already upserts the same profile; the direct merge keeps the UI consistent
+ even if WS is delayed. The merge (`applyProfileDuplicated` in
+ `use-profile-duplicate.ts`) dedupes by ID, preserves WS-delivered options
+ whose owning agent is absent, never lets a stale duplicate response clobber
+ a newer `agent.profile.updated` version (newer `updatedAt` wins), and
+ always rebuilds the copy option with the known agent metadata.
+
+### Profile settings page: header Duplicate button
+
+- `apps/web/components/settings/agent-profile-page.tsx`: add a Duplicate
+ button to `ProfileEditorHeader` (copy icon + `t("agents:duplicate")`,
+ `data-testid="duplicate-profile-header"`, disabled + `aria-busy` while a
+ duplicate is in flight). The flow lives in the extracted
+ `useProfileDuplicateAction` hook
+ (`components/settings/agent-profile-duplicate-action.ts`, unit-tested):
+ a ref-based in-flight guard (two rapid clicks can never issue two
+ copies), then save EVERY dirty contributor via the shared settings save
+ coordinator (`useSettingsSaveCoordinator().saveAll` — the profile editor
+ AND its MCP card; `saveAll` respects each contributor's `canSave`, and the
+ abort toasts the blocking contributor's `invalidReason` — MCP error or
+ profile-name validation), POST the duplicate, merge the copy into the
+ store, toast `agents:duplicateProfileSuccess`, cancel any pending
+ navigation intent the dirty guard had blocked, and SPA-navigate via
+ `runWithNavigationBlockerBypassed(() => router.push(...))` — never
+ `window.location.assign`, so the success toast survives and the
+ dirty-settings blocker is already resolved by the save. The row-level
+ duplicate hook guards against double-clicks (per-profile in-flight set).
+ The profile save path (`syncAgentsToStore`) reconciles the options slice
+ by ID (`reconcileAgentProfileOptions`), preserving WS-delivered orphan
+ options exactly like the duplicate merge. The merge keeps a newer
+ WS-delivered orphan option (revision carried on the option as `updatedAt`)
+ over a stale duplicate HTTP response, matching the newer-wins rule used
+ when the owning agent is present.
+
+### i18n
+
+Add to `apps/web/src/locales/en/agents.json`:
+
+- `"duplicate": "Duplicate"`
+- `"duplicateProfile": "Duplicate profile"`
+- `"duplicateProfileNamed": "Duplicate {{name}}"`
+- `"duplicateProfileSuccess": "Profile duplicated"`
+- `"failedToDuplicateProfile": "Failed to duplicate profile"`
+
+Regenerate the pseudo locale (`pnpm --filter @kandev/web i18n:pseudo`). Real
+locales (`zh-cn`, `pt-pt`) fall back to en; key-parity is a warning there,
+missing en keys are a hard error.
+
+### Tests (frontend)
+
+- `apps/web/app/settings/agents/profile-list-item.test.tsx`: extend with a
+ case asserting the Duplicate button renders and calls `onDuplicate` with
+ the profile (mirroring the existing toggle tests).
+- `apps/web/lib/api/domains/agent-profile-normalize.test.ts` or the actions
+ layer: only if an existing action-test pattern exists; otherwise the
+ component test plus E2E covers the contract.
+
+## E2E
+
+New `apps/web/e2e/tests/settings/agent-profile-duplicate.spec.ts` modeled on
+`agent-profile-delete.spec.ts`:
+
+- Create a source profile via `apiClient.createAgentProfile(agent.id,
+ "Dup Me", { model: agent.profiles[0].model, cli_flags: [...], command_prefix: ... })`.
+- `testPage.goto("/settings/agents")`, wait for the profile list, click the
+ duplicate button on the "Dup Me" row (`duplicate-profile-`).
+- Expect a "Dup Me Copy" row to appear without reload.
+- Navigate to the copy's profile page and assert the copied model/cli flag
+ values render.
+- `finally`: delete both profiles via `apiClient.deleteAgentProfile(..., true)`.
+
+## Implementation Waves
+
+Execution is sequential in the primary conversation; no subagents are
+authorized.
+
+Wave 1:
+
+- [x] [Task 01: Backend duplicate endpoint](task-01-backend-duplicate-endpoint.md)
+
+Wave 2:
+
+- [x] [Task 02: Frontend duplicate UI](task-02-frontend-duplicate-ui.md)
+
+Wave 3:
+
+- [x] [Task 03: E2E duplicate flow](task-03-duplicate-e2e.md)
+
+## Risks
+
+- `DuplicateAgentProfile` inserts the copy with the caller-provided enabled
+ state inside one transaction, unlike `CreateAgentProfile` which forces
+ `Enabled=true` for other callers — a store regression that forces the
+ duplicate enabled is pinned by `sqlite_duplicate_test.go` (disabled copy
+ stays disabled) and by the controller test asserting no follow-up write.
+- `GetAgentProfileMcpConfig` returns different "absent" shapes across the
+ sqlite store (`sql.ErrNoRows`) and the shared fake store (`nil, nil`);
+ the controller must tolerate both.
+- The list-page direct store merge and the WS `agent.profile.created`
+ broadcast can both insert the copy; the WS handler upserts by ID so this
+ is safe (verify while implementing).
diff --git a/docs/plans/agent-profile-duplicate/task-01-backend-duplicate-endpoint.md b/docs/plans/agent-profile-duplicate/task-01-backend-duplicate-endpoint.md
new file mode 100644
index 0000000000..3df3b80332
--- /dev/null
+++ b/docs/plans/agent-profile-duplicate/task-01-backend-duplicate-endpoint.md
@@ -0,0 +1,81 @@
+---
+id: "01-backend-duplicate-endpoint"
+title: "Add the backend profile duplicate endpoint"
+status: done
+wave: 1
+depends_on: []
+plan: "plan.md"
+spec: "../../specs/agents/profile-duplicate.md"
+---
+
+# Task 01: Backend profile duplicate endpoint
+
+## Acceptance
+
+- `POST /api/v1/agent-profiles/:id/duplicate` (interlock-protected) creates a
+ new profile named ` Copy` with a distinct ID and
+ `user_modified: true`, copying model, fallback model, auto-fallback, mode,
+ config options, allow-indexing, auto-approve, CLI passthrough, CLI flags,
+ env vars (secret refs included), command prefix, enabled state, and the
+ source's MCP config row (enabled + servers + meta) when one exists.
+- Runtime state is not copied: the copy is idle, no pause reason, no last-run
+ timestamp, zero consecutive failures.
+- A disabled source produces a disabled copy; an enabled source produces an
+ enabled copy.
+- The copy is committed atomically (row + MCP config in one repository
+ transaction, inserted with the source's enabled state): a failure leaves no
+ partial profile and a disabled source never becomes briefly selectable.
+- Unknown or soft-deleted source ID → `ErrAgentProfileNotFound` → HTTP 404,
+ and nothing is created.
+- An office-scoped source (non-empty `workspace_id`) → `ErrAgentProfileNotFound`
+ → HTTP 404 (existence hidden), rejected before MCP config is read or any
+ row is written, with zero broadcasts on any channel (global or
+ workspace-scoped).
+- Success returns the new `AgentProfileDTO` and broadcasts the
+ `agent.profile.created` WS notification with `{"profile": }`.
+- The route is added to the interlock 403 route list.
+
+## Verification
+
+- RED/GREEN controller:
+ `cd apps/backend && go test -run 'TestDuplicateProfile' ./internal/agent/settings/controller`
+- Interlock list:
+ `cd apps/backend && go test -run 'TestRegisterRoutesProtectsEveryStateChangingAgentSettingsRoute' ./internal/agent/settings/handlers`
+- Full package after refactor:
+ `cd apps/backend && go test ./internal/agent/settings/...`
+
+## Files likely touched
+
+- `apps/backend/internal/agent/settings/controller/profile_crud.go`
+- `apps/backend/internal/agent/settings/controller/profile_duplicate_test.go` (new)
+- `apps/backend/internal/agent/settings/controller/reconciler_test.go` (extend shared `fakeStore` with MCP config methods + `DuplicateAgentProfile`, additively)
+- `apps/backend/internal/agent/settings/store/store.go` (add `DuplicateAgentProfile` to the repository interface)
+- `apps/backend/internal/agent/settings/store/sqlite.go` (atomic `DuplicateAgentProfile` in one transaction; shared insert/upsert helpers)
+- `apps/backend/internal/agent/settings/store/sqlite_duplicate_test.go` (new)
+- `apps/backend/internal/agent/settings/handlers/handlers.go`
+- `apps/backend/internal/agent/settings/handlers/interim_settings_interlock_test.go`
+- Optional: `apps/backend/internal/agent/settings/handlers/profile_duplicate_handlers_test.go`
+
+## Dependencies
+
+None.
+
+## Parallelism
+
+Sequential by default; file-disjoint from Tasks 02–03 and may run in parallel
+only with explicit user authorization.
+
+## Inputs
+
+- Spec duplicate scenarios
+- `profile_crud.go` existing `DeleteProfile` not-found mapping and
+ `CreateProfile` field list; `store.Repository` interface; sqlite
+ `CreateAgentProfile` / `GetAgentProfileMcpConfig` /
+ `UpsertAgentProfileMcpConfig`; `ws.ActionAgentProfileCreated` broadcast
+ pattern from `httpCreateProfile`.
+
+## Output contract
+
+Report RED and GREEN results, the response/error contract, changed files, the
+enabled-state and MCP-copy behavior, and update this task plus `plan.md`
+status.
diff --git a/docs/plans/agent-profile-duplicate/task-02-frontend-duplicate-ui.md b/docs/plans/agent-profile-duplicate/task-02-frontend-duplicate-ui.md
new file mode 100644
index 0000000000..71de7c13f7
--- /dev/null
+++ b/docs/plans/agent-profile-duplicate/task-02-frontend-duplicate-ui.md
@@ -0,0 +1,72 @@
+---
+id: "02-frontend-duplicate-ui"
+title: "Add the frontend duplicate UI"
+status: done
+wave: 2
+depends_on: ["01-backend-duplicate-endpoint"]
+plan: "plan.md"
+spec: "../../specs/agents/profile-duplicate.md"
+---
+
+# Task 02: Frontend duplicate UI
+
+## Acceptance
+
+- `duplicateAgentProfileAction(profileId)` POSTs to
+ `/api/v1/agent-profiles/:id/duplicate` and returns the normalized
+ `AgentProfile`.
+- Each profile row on `/settings/agents` shows a Duplicate icon button
+ (outside the row link, beside the enabled switch) with an accessible label
+ `Duplicate `, `data-testid="duplicate-profile-"`, and a touch
+ target of at least 44×44px. Clicking it creates the copy and adds the new
+ row to the store immediately (toast on success/failure). No navigation.
+- The profile settings page header (`/settings/agents//profiles/`)
+ shows a Duplicate button (`data-testid="duplicate-profile-header"`,
+ `min-h-11` touch target). On success it toasts and navigates to the copy's
+ settings page.
+- All new user-facing copy goes through `t()`; the persisted copy name stays
+ server-side (` Copy`) and is not localized.
+- New en keys exist in `agents.json`; the pseudo locale is regenerated;
+ `i18n:check` and `i18n:ratchet` pass for changed lines.
+
+## Verification
+
+- Component test:
+ `cd apps/web && pnpm vitest run app/settings/agents/profile-list-item.test.tsx`
+- i18n:
+ `cd apps/web && pnpm run i18n:pseudo && pnpm run i18n:check`
+- Typecheck + lint of changed files:
+ `cd apps/web && pnpm run typecheck`
+ `cd apps && pnpm --filter @kandev/web lint` (or the repo's configured lint command)
+
+## Files likely touched
+
+- `apps/web/app/actions/agents.ts`
+- `apps/web/app/settings/agents/profile-list-item.tsx`
+- `apps/web/app/settings/agents/profile-list-item.test.tsx`
+- `apps/web/app/settings/agents/page.tsx`
+- `apps/web/components/settings/agent-profile-page.tsx`
+- `apps/web/src/locales/en/agents.json`
+- `apps/web/src/locales/pseudo/agents.json` (regenerated)
+
+## Dependencies
+
+Task 01 (endpoint must exist for the action to hit).
+
+## Parallelism
+
+Sequential by default; may run in parallel with Task 03 only with explicit
+user authorization.
+
+## Inputs
+
+- Spec duplicate scenarios and API surface
+- `useProfileEnabledToggle` / `applyEnabledProfileUpdate` store-merge
+ pattern; `agent-profile-page-state.ts` delete/navigate flow; `normalizeAgentProfile`;
+ `ws/handlers/agents.ts` `handleProfileCreated` upsert-by-ID behaviour
+ (verify no double-row when the direct merge and WS both insert).
+
+## Output contract
+
+Report RED and GREEN results, store-merge approach, toast keys, changed
+files, and update this task plus `plan.md` status.
diff --git a/docs/plans/agent-profile-duplicate/task-03-duplicate-e2e.md b/docs/plans/agent-profile-duplicate/task-03-duplicate-e2e.md
new file mode 100644
index 0000000000..62ba05b846
--- /dev/null
+++ b/docs/plans/agent-profile-duplicate/task-03-duplicate-e2e.md
@@ -0,0 +1,56 @@
+---
+id: "03-duplicate-e2e"
+title: "Add the E2E duplicate flow"
+status: done
+wave: 3
+depends_on: ["01-backend-duplicate-endpoint", "02-frontend-duplicate-ui"]
+plan: "plan.md"
+spec: "../../specs/agents/profile-duplicate.md"
+---
+
+# Task 03: E2E duplicate flow
+
+## Acceptance
+
+- An E2E spec (`agent-profile-duplicate.spec.ts`) proves the user-facing
+ flow: create a profile with distinctive settings via `apiClient`, open
+ `/settings/agents`, click its Duplicate button, and see a
+ ` Copy` row appear without a page reload.
+- The copy's profile page shows the copied settings (model / CLI flag /
+ command prefix) matching the source.
+- The spec cleans up both profiles in `finally`.
+
+## Verification
+
+- `cd apps/web && pnpm e2e:raw --grep "agent profile duplicate"` (or the
+ repo's E2E runner for `tests/settings/agent-profile-duplicate.spec.ts`).
+- Mobile parity: the new row button must be reachable at mobile widths; reuse
+ the desktop spec unless a mobile-only interaction appears (the icon button
+ sits outside the row link exactly like the existing switch, which already
+ has mobile coverage patterns).
+
+## Files likely touched
+
+- `apps/web/e2e/tests/settings/agent-profile-duplicate.spec.ts` (new)
+- `apps/web/e2e/tests/settings/mobile-agent-profile-duplicate.spec.ts` (new — mobile parity: Pixel 5 tap on the 44px row control, copy row appears, no horizontal overflow)
+
+## Dependencies
+
+Tasks 01 and 02 (endpoint and UI must exist).
+
+## Parallelism
+
+Sequential by default; may run in parallel with Task 02 only with explicit
+user authorization.
+
+## Inputs
+
+- Spec duplicate scenarios
+- `agent-profile-delete.spec.ts` structure (apiClient setup, testPage.goto,
+ row assertions); `apiClient.createAgentProfile` / `deleteAgentProfile`
+ helpers; `cleanupTestProfiles` convention.
+
+## Output contract
+
+Report the passing E2E run (or the exact failure to investigate), cleanup
+behaviour, changed files, and update this task plus `plan.md` status.
diff --git a/docs/specs/agents/profile-duplicate.md b/docs/specs/agents/profile-duplicate.md
new file mode 100644
index 0000000000..17866efd40
--- /dev/null
+++ b/docs/specs/agents/profile-duplicate.md
@@ -0,0 +1,106 @@
+---
+status: draft
+created: 2026-08-11
+owner: kandev
+---
+
+# Duplicate an Agent Profile
+
+## Why
+
+Profiles are the per-agent configuration unit (model, mode, config options,
+CLI flags, env vars, launcher prefix, auto-approve). Creating a variant of an
+existing profile means re-entering every field by hand today: there is no way
+to start from a working configuration. Users need a one-click "duplicate" that
+copies a profile's full configuration under a new name, so they can tweak the
+copy (a different model, an extra CLI flag, a sandbox launcher) without
+touching the source.
+
+## What
+
+- Every profile row on the settings agents page
+ (`/settings/agents`, the "Manage existing profiles by agent" list) gets a
+ **Duplicate** action.
+- The profile settings page
+ (`/settings/agents//profiles/`) gets the same **Duplicate**
+ action in its header.
+- Duplicating creates a new profile that is a faithful copy of the source's
+ configuration: name-derived new name, model, fallback model, auto-fallback,
+ mode, config options, allow-indexing, auto-approve, CLI passthrough, CLI
+ flags, env vars, command prefix, enabled state, and MCP config (enabled
+ flag + servers + meta) when the source has one.
+- The copy is an independent row: it gets a new ID, `user_modified` is set,
+ and editing or deleting it never affects the source. No session, task,
+ watcher, automation, or routing reference points at the copy.
+- The copy is committed atomically: the row is inserted with the source's
+ enabled state and the MCP config row is upserted in one repository
+ transaction, so a duplicated profile inherits the source's selection state
+ and a disabled source never becomes briefly selectable. A failure rolls
+ back and leaves no partial copy.
+- Runtime state is never copied: the copy starts idle with no pause reason,
+ no last-run timestamp, and a zero consecutive-failure count. Office
+ enrichment configuration (workspace, role, budget, permissions, skills,
+ executor preference, …) is copied when present, matching the faithful-copy
+ intent; the settings surface only lists global (non-office) profiles, so in
+ practice those fields are empty on the rows this feature shows.
+- The generated name is persisted user data, not UI copy: it is
+ ` Copy` (e.g. `Default` → `Default Copy`), matching the
+ repo convention that stored names do not depend on the locale they were
+ created in (same rule as seeded executor and repository names).
+
+## API surface
+
+`POST /api/v1/agent-profiles/:id/duplicate` (interim-settings-interlock
+protected, like every other profile mutation):
+
+- Request body: none. The copy name is derived server-side as
+ ` Copy`.
+- Response `200`: the new `AgentProfileDTO` (same shape as
+ `POST /agents/:id/profiles`).
+- `404` when the source profile does not exist or is soft-deleted.
+- Broadcasts the existing `agent.profile.created` WebSocket notification so
+ every open settings surface picks the copy up live.
+
+The endpoint is not idempotent in the HTTP sense: each call creates one new
+row (there is no idempotency key), so a retried POST after a network timeout
+may create a second copy. Callers must treat duplicates as one-shot
+operations; the UI guards against double-clicks. The copy performs no
+reference checks because a brand-new row cannot be referenced by anything
+yet.
+
+## Scenarios
+
+- **GIVEN** a profile named `Default` with model, CLI flags, env vars, and a
+ command prefix, **WHEN** the user clicks Duplicate on its row in
+ `/settings/agents`, **THEN** a new profile row `Default Copy` appears
+ immediately with every configuration field equal to the source, a distinct
+ ID, and `user_modified` true.
+- **GIVEN** an MCP-capable agent profile with an MCP config (enabled with
+ servers), **WHEN** it is duplicated, **THEN** the copy has the same MCP
+ enabled state, servers, and meta under the new profile ID.
+- **GIVEN** a disabled profile, **WHEN** it is duplicated, **THEN** the copy
+ is also disabled.
+- **GIVEN** a profile with an active session, **WHEN** it is duplicated,
+ **THEN** the duplicate succeeds (unlike delete, no in-use checks apply) and
+ the session keeps using the source.
+- **GIVEN** the profile settings page of a profile, **WHEN** the user clicks
+ Duplicate in the header, **THEN** a toast confirms the copy and the user is
+ taken to the copy's settings page to edit it.
+- **GIVEN** an unknown profile ID, **WHEN** the duplicate endpoint is called,
+ **THEN** it returns `404` and creates nothing.
+
+## Out of scope
+
+- Duplicating office workspace agents through the office UI (`/office/agents`):
+ office has its own agent creation flows and permission model. This feature
+ targets the `/settings/agents` profile flavor. The settings duplicate
+ endpoint is fail-closed against office-scoped sources: a profile with a
+ non-empty `workspace_id` returns `404` (existence hidden) before any MCP
+ read or write, so the instance-level settings surface can never read or
+ clone another workspace's configuration. Office duplication, when added,
+ belongs on the workspace-scoped office API surface.
+- Renaming after duplicate: the copy is a normal profile the user renames via
+ the existing profile editor.
+- Bulk/queue duplication, templates, or copy-paste between agents.
+- Choosing the copy name in the duplicate dialog: name is derived, then edited
+ on the copy's settings page.