Generic collections (factory_job refs) and client tools (integration branch; draft, do not merge)

.github/workflows/ci.yml

@@ -36,12 +36,14 @@ on:
       - dev
       - app/v3
       - santos/dev2
+      - workstreams/main
   # Also on the push, because a merge of two individually-green branches can
   # still be red, and the merge is exactly the moment nobody is watching.
   push:
     branches:
       - dev
       - santos/dev2
+      - workstreams/main
   workflow_dispatch:
 
 permissions:

cmd/codeaf/app.go

@@ -203,6 +203,7 @@ func runApp(args []string) error {
 	// ONE SUPERVISOR FOR EVERY CONVERSATION THE APP BUILDS (appservices.go).
 	services := openAppServices()
 	appServiceDoor.Store(services)
+	appClientToolsBackend.Store(backend)
 	backend.attachServices(services)
 	guard.Go("app/crews-start", func() { backend.crews() })
 	// THE APP IS AN OPEN WINDOW for as long as it runs, so the clock that runs
@@ -561,6 +562,7 @@ func appConnOf(client *remote.Client, release func(), assembled bool) *appConn {
 
 // appBackend is the [appwire.Engine] over this process's conversations.
 type appBackend struct {
+	clientTools    appClientTools
 	libraryWatch   sync.Once
 	libraryInboxMu sync.Mutex
 	pluginPauses   map[string]appPluginPause
@@ -763,6 +765,7 @@ type appBackend struct {
 	collections       *workspace.Store
 	collectionsClosed bool
 	collectionsPath   string
+	collectionFactory collectionFactory
 	// services is the app's one supervisor of kept-running processes
 	// (appservices.go); nil is the capability absent.
 	services *appServices
@@ -1276,10 +1279,12 @@ func appRowOnDisk(id string) (session.SessionRow, bool) {
 		// A folder minted and never spoken in is still a conversation the app
 		// may have created; its meta names the workspace.
 		meta, err := session.LoadMeta(dir)
-		if err != nil || strings.TrimSpace(meta.ID) == "" {
+		if err != nil || meta.ID != id {
 			continue
 		}
-		return session.SessionRow{ID: id, AgentDID: meta.AgentDID(), Dir: dir, Transcript: transcript, Title: meta.Title, Workspace: meta.Workspace, Created: meta.Created}, true
+		return session.SessionRow{ID: id, AgentDID: meta.AgentDID(), Dir: dir, Transcript: transcript,
+			Title: meta.Title, Workspace: meta.Workspace, Owned: meta.Owned, Model: meta.Model,
+			Archived: meta.Archived, Spend: meta.SpentUSD, At: meta.Created, Created: meta.Created}, true
 	}
 	return session.SessionRow{}, false
 }
@@ -1934,6 +1939,9 @@ func (b *appBackend) hold(a *appAgent, conn *appConn, workspace string) appwire.
 	if door, ok := conn.Conv.(interface{ ModelIdentity() session.ModelIdentity }); ok {
 		state := door.ModelIdentity()
 		modelIdentity = &state
+		if state.Selected != "" {
+			model = state.Selected
+		}
 	}
 	effort := conn.Conv.ReasoningFor(model)
 	if dial, ok := conn.Conv.(interface{ ConversationEffort() string }); ok {
@@ -1987,6 +1995,7 @@ func (b *appBackend) hold(a *appAgent, conn *appConn, workspace string) appwire.
 		a.crewHeld = a.crewHeld || crewHeld
 		view = a.view
 	})
+	b.holdClientTools(a, live)
 	startTitles()
 	b.flushSync(a)
 	b.locked(func() { view = a.view })
@@ -2918,7 +2927,7 @@ func (b *appBackend) pump(a *appAgent, id string, live *appLive, turn uint64, n
 			b.stepMoved(a, live, title)
 			row := b.callBegan(a, id, turn, event, title)
 			row.Summary = event.Hint
-			live.box.Event(appwire.EventTurnTool, row)
+			live.sayTool(row)
 		case session.EventToolOutput:
 			b.callOutput(a, id, live, event)
 		case session.EventToolFinished:
@@ -2937,7 +2946,7 @@ func (b *appBackend) pump(a *appAgent, id string, live *appLive, turn uint64, n
 			if title == "" {
 				title = redact.Secrets(tui3.ToolTitle(event.Tool, event.Args, ""))
 			}
-			live.box.Event(appwire.EventTurnTool, b.callEnded(a, id, turn, event, title, summary, appDetail(summary), succeeded))
+			live.sayTool(b.callEnded(a, id, turn, event, title, summary, appDetail(summary), succeeded))
 			b.noteContext(a, live)
 			// THE SEVENTEENTH PROCESS is refused by the engine, and the turn
 			// says so once at its end.
@@ -4572,6 +4581,8 @@ func (b *appBackend) Close() error {
 	if b.leaving != nil {
 		b.leaving()
 	}
+	b.clientTools.disconnect()
+	appClientToolsBackend.CompareAndSwap(b, nil)
 	already := false
 	var crews *appCrewRun
 	var agents []*appAgent

cmd/codeaf/app_model_for_now_test.go

@@ -0,0 +1,136 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/Agent-Field/codeaf/internal/appwire"
+	"github.com/Agent-Field/codeaf/internal/config"
+	"github.com/Agent-Field/codeaf/internal/home"
+	"github.com/Agent-Field/codeaf/internal/modelsource/sourcestub"
+	"github.com/Agent-Field/codeaf/internal/session"
+)
+
+// C1, C2, C3: the app reopens the saved choice and title route, leaving settings
+// and setup state byte-identical across an automatic run-only selection.
+func TestAppReopensConfiguredModelAfterRunOnlyReplacement(t *testing.T) {
+	t.Setenv(home.EnvVar, t.TempDir())
+	profile := t.TempDir()
+	t.Setenv(config.ProfileDirEnv, profile)
+	dir, workspace := t.TempDir(), t.TempDir()
+	path := filepath.Join(dir, "transcript.jsonl")
+	provider := sourcestub.New("vendor/configured", "available/model", "vendor/backup")
+	defer provider.Close()
+	settings := []byte(`{
+  "model.talk": "vendor/configured",
+  "models.tiers.low": "",
+  "models.tiers.reflex": "vendor/reflex",
+  "models.tiers.worker": "vendor/worker",
+  "models.tiers.high": "vendor/checker",
+  "models.tiers.mastermind": "vendor/planner",
+  "models.roles": "planner:vendor/planner",
+  "task.model": "vendor/task",
+  "models.tasks.mode": "auto",
+  "models.tasks.one": "vendor/one"
+}
+`)
+	if err := os.WriteFile(config.BudgetConfigPath(profile), settings, 0600); err != nil {
+		t.Fatal(err)
+	}
+	rolesSource, err := v3RolesSource(workspace, profile)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := session.Config{Workspace: workspace, Place: session.Place{Dir: dir, Workspace: workspace}, SessionFile: path,
+		Model: "vendor/configured", APIKey: "fixture", BaseURL: provider.URL(), ProfileDir: profile, System: "SYSTEM",
+		RolesSource:        rolesSource,
+		ConversationModels: &session.ConversationModels{Main: "vendor/configured", Fallback: "vendor/backup"},
+	}
+	a, err := session.New(cfg)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer a.Close()
+	var reopened *session.Agent
+	b := newFakeBackend(newAppRecorder(), func(ask appOpenAsk) (*appConn, error) {
+		meta, err := session.LoadMeta(dir)
+		if err != nil {
+			return nil, err
+		}
+		fresh := cfg
+		fresh.Model = meta.Model
+		reopened, err = session.New(fresh)
+		if err != nil {
+			return nil, err
+		}
+		return &appConn{Conv: reopened, Workspace: workspace, Transcript: path, Release: func() { _ = reopened.Close() }}, nil
+	})
+	defer b.Close()
+	b.state = &appState{path: filepath.Join(t.TempDir(), appStateName)}
+	if err := b.state.write(func(f *appStateFile) error {
+		f.Setup = &appwire.Setup{DefaultModel: cfg.Model}
+		return nil
+	}); err != nil {
+		t.Fatal(err)
+	}
+	stateBefore, err := os.ReadFile(b.state.where())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := a.UseModelForNow("available/model"); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second)
+	defer cancel()
+	events, err := a.Submit(ctx, "respond on the available model")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for event := range events {
+		if event.Kind == session.EventError {
+			t.Fatalf("scripted turn failed: %v", event.Err)
+		}
+	}
+	if err := a.Close(); err != nil {
+		t.Fatal(err)
+	}
+	a.SettleWrites()
+	profileAfter, err := os.ReadFile(config.BudgetConfigPath(profile))
+	if err != nil || !bytes.Equal(settings, profileAfter) {
+		t.Fatalf("fallback wrote profile: %s, %v", profileAfter, err)
+	}
+	stateAfter, err := os.ReadFile(b.state.where())
+	if err != nil || !bytes.Equal(stateBefore, stateAfter) {
+		t.Fatalf("fallback wrote app setup: %s, %v", stateAfter, err)
+	}
+	row, ok := session.ReadRows([]string{path})[filepath.Clean(path)]
+	if !ok {
+		t.Fatal("saved conversation is missing from app inventory")
+	}
+	listed := appRowView(row)
+	if listed.Model != cfg.Model || listed.ModelIdentity == nil || listed.ModelIdentity.Selected != cfg.Model {
+		t.Fatalf("agents.list row=%+v", listed)
+	}
+	b.remember(row)
+	opened, err := b.OpenAgent(listed.ID)
+	if err != nil || opened.Model != cfg.Model {
+		t.Fatalf("agents.open=%+v, %v", opened, err)
+	}
+	routes, _, err := b.errandRoutes(listed.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, route := range routes {
+		if route.Role == "title" {
+			if route.Model != cfg.Model {
+				t.Fatalf("agents.errand.models title=%+v", route)
+			}
+			return
+		}
+	}
+	t.Fatal("agents.errand.models omitted title")
+}

cmd/codeaf/appblank.go

@@ -139,7 +139,7 @@ func (b *appBackend) reapBlank(a *appAgent) bool {
 	}
 	gone := false
 	_ = teamstore.InspectConversation(b.crewProfile(), transcript, func(referenced bool) error {
-		if referenced || session.InUse(transcript) || !v3EmptyUnassignedSession(dir) {
+		if referenced || session.InUse(transcript) || !v3EmptyUnassignedSession(dir) || collectionKeepsConversation(dir) {
 			return nil
 		}
 		gone = os.RemoveAll(dir) == nil