Skip to content
Merged
Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
16 commits
Select commit Hold shift + click to select a range
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
fix(team): preserve selected presets and fence turn configuration
  • Loading branch information
SivanCola committed Nov 3, 2026
commit 6ad09b10984aa46149b5cb44619981ead2a66a76
2 changes: 1 addition & 1 deletion desktop/frontend/src/components/TeamSettingsPage.tsx
Original file line number Diff line number Diff line change
Expand Up @@ -141,7 +141,7 @@ function TeamAgentEditor({initial,memberID,revision,tabId,workspaceKey,onSaved,o
const patch=(next:Partial<TeamAgentSettings>)=>setDraft(previous=>({...previous,...next}));
const dirty=editingIcon||JSON.stringify(draft)!==JSON.stringify(initial)||presetID!==undefined;
const invalid=!draft.name.trim()||draft.name.length>40||editingIcon;
const submit=()=>operation.save({draft,presetID},requestId=>app.SaveTeamAgent({id:memberID,expectedRevision:revision,requestId,settings:draft,presetId:presetID}));
const submit=()=>operation.save(draft,requestId=>app.SaveTeamAgent({id:memberID,expectedRevision:revision,requestId,settings:draft}));
const guard=useSettingsDraft({label:t("team.members"),order:1,dirty,busy:operation.busy,canSave:!invalid,save:submit,discard:()=>{setDraft(initial);setPresetID(undefined);}});
useEffect(()=>{let current=true;void app.Models().then(list=>{if(current)setModels(list);},cause=>{if(current)setModelError(String(cause));});return()=>{current=false;};},[]);
if(editingPreset) {
Expand Down
4 changes: 3 additions & 1 deletion desktop/team_api.go
Original file line number Diff line number Diff line change
Expand Up @@ -222,7 +222,9 @@ func (a *App) SaveTeamAgent(req SaveTeamAgentRequest) (TeamMutationResult, error
definition := settings.Preset.definition()
preset = &definition
}
if req.PresetID != nil {
// An explicit copy is the user's selected definition, including project
// scope. The member's execution directory is not its preset source.
if preset == nil && req.PresetID != nil {
resolved, err := agentpreset.Resolve(boot.AgentPresetDirs(settings.Folder), *req.PresetID)
if err != nil {
return "", err
Expand Down
55 changes: 55 additions & 0 deletions desktop/team_api_test.go
Original file line number Diff line number Diff line change
@@ -1,12 +1,67 @@
package main

import (
"reflect"
"testing"

"deepzora/internal/agentpreset"
"deepzora/internal/boot"
)

func TestTeamAgentCopiesSelectedProjectPresetIntoIndependentDirectory(t *testing.T) {
for _, targetDirectory := range []string{"default", "other-project"} {
for _, legacyID := range []bool{false, true} {
t.Run(targetDirectory+map[bool]string{false: "/snapshot", true: "/snapshot-with-id"}[legacyID], func(t *testing.T) {
isolateDesktopUserDirs(t)
a := NewApp()
a.ctx = t.Context()
installNoopRuntimeEvents(a)
t.Cleanup(func() {
if err := a.stopTeamHost(); err != nil {
t.Error(err)
}
})
id, sourceRoot, targetRoot := "review", t.TempDir(), ""
if targetDirectory == "other-project" {
targetRoot = t.TempDir()
if _, err := agentpreset.Write(boot.AgentPresetDirs(targetRoot).Project, id, "WRONG_TARGET_PROJECT"); err != nil {
t.Fatal(err)
}
}
if _, err := agentpreset.Write(boot.AgentPresetDirs("").User, id, "WRONG_USER_PRESET"); err != nil {
t.Fatal(err)
}
if _, err := agentpreset.Write(boot.AgentPresetDirs(sourceRoot).Project, id, "---\nname: Source project\ncomplete: true\ninclude-runtime-context: false\ntools: []\n---\nSELECTED_PROJECT_PERSONA"); err != nil {
t.Fatal(err)
}
selected, err := agentpreset.Resolve(boot.AgentPresetDirs(sourceRoot), id)
if err != nil {
t.Fatal(err)
}
req := SaveTeamAgentRequest{RequestID: "copy-project-snapshot", Settings: TeamAgentSettings{Name: "Ada", Permission: "read-only", Folder: targetRoot, Preset: teamPresetView(&selected)}}
if legacyID {
req.PresetID = &id
}
result, err := a.SaveTeamAgent(req)
if err != nil || result.Outcome != "applied" {
t.Fatalf("copy selected project preset: %+v %v", result, err)
}
copied := result.View.Roster.Agents[0].Preset
if !reflect.DeepEqual(copied, req.Settings.Preset) {
t.Fatalf("changed selected configuration: got %+v, want %+v", copied, req.Settings.Preset)
}
if _, err := agentpreset.Write(boot.AgentPresetDirs(sourceRoot).Project, id, "SOURCE_CHANGED_LATER"); err != nil {
t.Fatal(err)
}
view, err := a.GetTeam()
if err != nil || !reflect.DeepEqual(view.Roster.Agents[0].Preset, req.Settings.Preset) {
t.Fatalf("member did not retain independent copy: %+v %v", view, err)
}
})
}
}
}

func TestDesktopTeamConfigurationCASRetryAndPresetCopy(t *testing.T) {
isolateDesktopUserDirs(t)
a := NewApp()
Expand Down
158 changes: 158 additions & 0 deletions desktop/team_configuration_apply_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -2,19 +2,177 @@ package main

import (
"context"
"errors"
"fmt"
"net/http"
"net/http/httptest"
"reflect"
"strings"
"sync/atomic"
"testing"
"time"

"deepzora/internal/agentpreset"
"deepzora/internal/control"
"deepzora/internal/event"
"deepzora/internal/team"
)

func teamAdmissionFixture(t *testing.T) (*App, *WorkspaceTab, *control.Controller, string, TeamAgentSettings) {
t.Helper()
a := newManualSessionTestApp(t)
if _, err := a.SaveProviderWithKey(ProviderView{Name: "team-admission", Kind: "openai", BaseURL: "http://127.0.0.1:1", Models: []string{"test"}, NoProxy: true}, "disposable-fixture"); err != nil {
t.Fatal(err)
}
if err := a.SetDefaultModel("team-admission/test"); err != nil {
t.Fatal(err)
}
settings := TeamAgentSettings{Name: "Chief", Main: true, Permission: "read-only", Preset: &TeamPresetDefinition{ID: "copied", Name: "Copied", Complete: true, Body: "ORIGINAL_PERSONA", IncludeRuntimeContext: true}}
created, err := a.SaveTeamAgent(SaveTeamAgentRequest{RequestID: "create-admission-fixture", Settings: settings})
if err != nil || created.Outcome != "applied" {
t.Fatalf("create: %+v %v", created, err)
}
h, err := a.localTeamHost()
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() {
if err := a.stopTeamHost(); err != nil {
t.Error(err)
}
})
pane, err := h.Ensure(t.Context(), team.SeatRef{Agent: created.TargetID})
if err != nil {
t.Fatal(err)
}
owner := pane.(*desktopTeamRuntime).owner()
return a, owner, a.controllerForTab(owner).(*control.Controller), created.TargetID, settings
}

func saveTeamAdmissionSettings(t *testing.T, a *App, id string, settings TeamAgentSettings) {
t.Helper()
view, err := a.GetTeam()
if err != nil {
t.Fatal(err)
}
updated, err := a.SaveTeamAgent(SaveTeamAgentRequest{ID: id, ExpectedRevision: view.Roster.Revision, RequestID: "update-admission-fixture", Settings: settings})
if err != nil || updated.Outcome != "applied" {
t.Fatalf("save: %+v %v", updated, err)
}
}

func TestTeamTurnAdmissionRechecksConfigurationAfterConcurrentCommit(t *testing.T) {
for _, entry := range []string{"human", "inbox"} {
for _, change := range []string{"preset", "directory"} {
t.Run(entry+"/"+change, func(t *testing.T) {
a, owner, old, id, settings := teamAdmissionFixture(t)
if entry == "human" {
meta, err := a.RevealBackgroundRuntime(owner.ID)
if err != nil {
t.Fatal(err)
}
var current control.SessionAPI
owner, current = a.tabAndCtrlByID(meta.ID)
old = current.(*control.Controller)
}
if change == "directory" {
settings.Folder = t.TempDir()
} else {
if len(old.ToolContractEntries()) <= 1 {
t.Fatal("fixture must start with tools beyond the fixed capability proxy")
}
settings.Preset = &TeamPresetDefinition{ID: "copied", Name: "Copied", Complete: true, Body: "REPLACEMENT_PERSONA", IncludeRuntimeContext: false, RestrictTools: true, Tools: []string{}}
}
var committed atomic.Bool
// The save wins the writer boundary after the sender's optimistic
// check, before that sender can acquire its final admission lock.
a.lifecycleCheckpointHook = func(stage string) {
if stage == "team-turn-before-admission" && committed.CompareAndSwap(false, true) {
saveTeamAdmissionSettings(t, a, id, settings)
}
}
var admitted control.SessionAPI
var err error
if entry == "inbox" {
var release func()
release, err = a.beforeInboxDispatch(old)
if release != nil {
release()
}
} else {
var admission *tabTurnAdmission
admission, admitted, err = a.beginTabTurn(owner.ID, false)
if admission != nil {
admission.abort()
}
}
if !committed.Load() {
t.Fatalf("test did not cross the intended configuration boundary: %v", err)
}
if change == "directory" {
if err == nil || !strings.Contains(err.Error(), "working directory changed") {
t.Fatalf("stale directory binding admitted: %v", err)
}
return
}
if entry == "inbox" {
if !errors.Is(err, control.ErrInboxRuntimeUnpublished) {
t.Fatalf("old inbox owner was not fenced after rebuild: %v", err)
}
} else if err != nil || admitted == old {
t.Fatalf("new turn did not use rebuilt controller: %v", err)
}
next := a.controllerForTab(owner).(*control.Controller)
view, err := a.GetTeam()
if err != nil || next == old || view.Seats[0].SettingsPending || !strings.Contains(next.SystemPrompt(), "REPLACEMENT_PERSONA") {
t.Fatalf("latest static configuration not applied: %+v %v", view, err)
}
// Empty preset tools retain only the existing fixed-schema proxy;
// its executor still enforces the empty underlying allowlist.
if entries := next.ToolContractEntries(); len(entries) != 1 || entries[0].Name != "use_capability" {
t.Fatal("new admission retained tools removed by the saved preset")
}
})
}
}
}

type pendingTeamAdmissionController struct{ *control.Controller }

func (c pendingTeamAdmissionController) RuntimeStateSnapshot() event.RuntimeStateSnapshot {
state := c.Controller.RuntimeStateSnapshot()
state.PendingPrompt = true
return state
}

func TestTeamTurnAdmissionRejectsPendingConfigurationWhilePromptIsActive(t *testing.T) {
a, owner, original, id, settings := teamAdmissionFixture(t)
settings.Preset.Body = "REPLACEMENT_PERSONA"
saveTeamAdmissionSettings(t, a, id, settings)
a.mu.Lock()
owner.Ctrl = pendingTeamAdmissionController{original}
a.mu.Unlock()
defer func() {
a.mu.Lock()
owner.Ctrl = original
a.mu.Unlock()
}()
var attempts atomic.Int32
a.lifecycleCheckpointHook = func(stage string) {
if stage == "team-turn-before-admission" && attempts.Add(1) > 1 {
t.Fatal("pending prompt caused an admission retry loop")
}
}
admission, _, err := a.beginRuntimeTurn(owner.ID, false, true)
if admission != nil {
admission.abort()
}
var busy *rebuildBusyError
if !errors.As(err, &busy) || !busy.work.pendingPrompt {
t.Fatalf("pending prompt should defer the new static configuration: %v", err)
}
}

func TestTeamPresetChangeWaitsForIdleAndPreservesCanonicalHistory(t *testing.T) {
a := newManualSessionTestApp(t)
ctx, cancel := context.WithTimeout(t.Context(), 30*time.Second)
Expand Down
17 changes: 17 additions & 0 deletions desktop/turn_admission.go
Original file line number Diff line number Diff line change
Expand Up @@ -128,6 +128,7 @@ func (a *App) beginRuntimeTurnWithModelChoice(tabID string, reclaim, detached bo
} else if applied {
continue
}
a.lifecycleCheckpoint("team-turn-before-admission")

a.runtimeAdmissionMu.RLock()
abort := func() {
Expand Down Expand Up @@ -173,6 +174,22 @@ func (a *App) beginRuntimeTurnWithModelChoice(tabID string, reclaim, detached bo
abort()
return nil, nil, control.ErrTurnRunning
}
// A roster commit can win the mutation lock after the optimistic apply
// above. Recheck under the final admission fence, including directory
// bindings, before reserving a foreground or durable inbox turn.
pending, err := a.teamPresetPending(tab, ctrl)
if err != nil {
abort()
return nil, nil, err
}
if pending {
busy := rebuildControllerActiveWorkErrorFor(ctrl, "team preset")
abort()
if busy != nil {
return nil, nil, busy
}
continue
}
usingApplied, choiceErr := validateModelApplicationChoice(ctrl, choice)
if choiceErr != nil {
abort()
Expand Down