Refine Teams overviews, shared conversations and scoped deletion

PERF.md

@@ -6,6 +6,29 @@ two thirds off the embedded corpora. This file is what keeps it. Every win below
 is defended by something that goes red locally, in `go test` or in `make check`,
 with a message that says what happened.
 
+## Teams overview reading bounds
+
+Visible teams’ member previews and latest-message times are read once per conversation
+key in the same serial batch, so shared membership does not duplicate journal reads.
+Member previews locate the latest human exchange off the UI loop by scanning journal
+record boundaries backwards. Unchanged size/mtime reuses the cached preview; remote
+journals are never opened on this machine. Reads use a **64 KiB** (`teamsPreviewBytes`)
+chunk and at most the first **64 KiB** of each record, including oversized JSON content
+strings. Finding the prompt can scan more than 64 KiB of a changed journal, but retained
+messages stay bounded to **64 KiB total** and **2 messages** (`teamsPreviewMessages`).
+The prompt retains up to one quarter of that byte budget, leaving space for the response's
+beginning. Front conversations use their displayed messages with the same retained bound.
+Manager cards remain capped at **14 rows** (`teamsManagerRows`), with an **8-row** minimum
+(`teamsManagerMinRows`). Interaction readings retain at most **200 entries** (`trafficKeep`),
+merged by id without consuming the live delivery cursor. The table paints at most **6 body
+rows** (`teamsInteractionRows`), reduced to fit the available pane, with a pinned header
+and independent paging. Sorting shares one subtree timestamp pass per frame, including
+live correction times. Mouse wheels move physical rows in the pane or sidebar under
+the pointer. Paint performs no filesystem or network reads.
+`TestTeamsPreviewRetainsBoundedTextAndFollowsUpdates`, the long-record exchange regressions,
+the overview navigation/geometry regressions and `TestTheFrameNeverReadsTheDisk` defend
+these bounds.
+
 ## Context recovery bounds
 
 Conversation request admission sums the existing encoded messages and tool schemas;
@@ -2407,7 +2430,7 @@ include the complete tab identity and picker availability, not just rendered wor
 
 
 The navigation panel renders a separate transcript separator and, inside a task,
-a separate metadata row. Its tab candidate slice is bounded to 32 entries;
+a separate metadata row. Its ordinary All tab candidate slice is bounded to 32 entries; a team overlay draws its complete stored membership without applying that presentation cap. Overlay frames build membership tabs from memory and never open agents or transcripts; the membership picker captures its saved-session snapshot off-loop once when opened.
 the recency stack and held agents remain uncapped. Membership walks can still
 inspect recency keys when candidates are dismissed or missing, but the renderer
 no longer builds an unbounded temporary tab list and compares each entry against
@@ -2773,6 +2796,15 @@ capture retains at most **4 KiB** while continuing to drain. Regression fixtures
 cover both engines, direct runtime roots, aliases, broad globs, subprocess
 termination, source worktrees, and growth during a snapshot read.
 
+## Saved conversation cards
+
+The Chats grid reads the switcher's world metadata off-loop at most every
+`wallCatalogEvery` (**3 seconds**) and caches canonical conversation keys before painting.
+Only visible saved cards read transcript tails, one batch at a time, under the
+shared `teamsPreviewBytes` (**64 KiB per transcript**) budget. Transcript pieces
+are rendered only for visible cards. Hosted catalogs never read local transcript
+paths. No saved conversation is resumed to display or select its card.
+
 ## Contextual memory bounds
 
 One ordinary post-turn extraction can add one memory claim. It keeps at most eight
@@ -2804,3 +2836,16 @@ Exact duplicate settlement streams the active owner partition transactionally: i
 cost grows with that partition, rather than losing punctuation or older duplicates
 behind a retrieval ceiling. The canonical event journal is not periodically pruned;
 projection/context work is bounded, while durable history continues to grow.
+
+## Conversation deletion completion
+
+Permanent deletion joins the task run's completion channel with
+`conversationDeletionGrace` (**30 seconds**), and keeps the journal lock on timeout.
+The cross-process deletion request uses the same grace while claiming the journal.
+Ordinary Close returns promptly but releases its journal only after the cancelled run's
+last store close, before signalling completion to a caller that may immediately reopen
+the conversation. Clearing the run and signalling completion happen together. Cleanup
+receipts are atomically replaced and synced before committing deletion. Startup recovery
+walks only the two saved-conversation directory levels, without following symlinked buckets.
+`internal/session/deletion_revision_test.go` drives completion and timeout with held
+channels and a zero test grace rather than sleeping for the production deadline.

cmd/codeaf-demo-home/seed.go

@@ -98,6 +98,10 @@ func seedDemoHome(dir string, now time.Time) (builtHome, error) {
 		built.Messages += 2 * len(talk.turns)
 	}
 
+	if err := writeTeams(root, projects, ids, now); err != nil {
+		return built, err
+	}
+
 	if err := writePlan(projects, ids); err != nil {
 		return built, err
 	}

cmd/codeaf-demo-home/seed_teams.go

@@ -0,0 +1,90 @@
+package main
+
+import (
+	"fmt"
+	"path/filepath"
+	"time"
+
+	"github.com/Agent-Field/agentfield/sdk/go/ai"
+	teamstore "github.com/Agent-Field/codeaf/internal/teams"
+)
+
+// The demo includes shared membership and enough exchanges to exercise the
+// overview's independent scrolling. Waking is disabled in this throwaway data
+// so opening a fixture never sends its historical requests to a provider.
+func writeTeams(root string, projects map[string]*demoProject, ids map[string]string, now time.Time) error {
+	quiet, cap := false, 5.0
+	var members []teamstore.Member
+	for _, talk := range demoConversations {
+		if talk.archived {
+			continue
+		}
+		p := projects[talk.project]
+		file := filepath.Join(p.bucket, ids[talk.title], "transcript.jsonl")
+		handle := teamstore.DeriveHandle(talk.title)
+		if len(members) == 0 {
+			handle = "coordinator"
+		}
+		members = append(members, teamstore.Member{Key: file, File: file, Where: p.dir, Word: talk.title, Handle: handle, HandleBy: teamstore.HandleByTyped})
+		if len(members) == 6 {
+			break
+		}
+	}
+	primary := teamstore.Team{ID: teamstore.NewID(), Name: "Interface cleanup", Members: members,
+		Manager: members[0].Key, Made: now.Add(-48 * time.Hour), Settings: teamstore.Settings{Wake: &quiet, CapUSDDay: &cap}}
+	primary.SetHue(teamstore.HueSpec{Hue: 200})
+	secondary := teamstore.Team{ID: teamstore.NewID(), Name: "Release notes", Members: []teamstore.Member{members[1], members[3]},
+		Manager: members[3].Key, Made: now.Add(-24 * time.Hour), Settings: teamstore.Settings{Wake: &quiet}}
+	secondary.SetHue(teamstore.HueSpec{Hue: 80})
+	previous := teamstore.Team{ID: teamstore.NewID(), Name: "Previous layout pass", Members: members[:1],
+		Manager: members[0].Key, Made: now.Add(-96 * time.Hour), Settings: teamstore.Settings{Wake: &quiet}}
+	file := teamstore.File{Teams: []teamstore.Team{primary, secondary, previous}}
+	if err := file.Close(previous.ID, now.Add(-72*time.Hour), ""); err != nil {
+		return err
+	}
+	if err := teamstore.Save(root, file.Teams); err != nil {
+		return err
+	}
+	for i := 0; i < 24; i++ {
+		member := members[1+i%(len(members)-1)]
+		text := fmt.Sprintf("Check the layout at width %d and report any clipped labels or missing actions.", 80+i*4)
+		at := now.Add(-time.Duration(24-i) * 3 * time.Minute)
+		id, err := teamstore.AppendTrafficID(root, primary.ID, teamstore.Entry{Kind: teamstore.KindNote, From: teamstore.FromManager, To: member.Handle, Text: text, At: at})
+		if err != nil {
+			return err
+		}
+		replyText := "The labels fit. The member preview and interaction links remain reachable at this width."
+		replyID, err := teamstore.AppendTrafficID(root, primary.ID, teamstore.Entry{Kind: teamstore.KindNote, From: member.Handle, To: teamstore.ToManager, Text: replyText, Answers: id, At: at.Add(time.Minute)})
+		if err != nil {
+			return err
+		}
+		// These journal entries use the same tool receipts and delivered message
+		// envelope as live sessions, so every demo interaction link can land.
+		callID := fmt.Sprintf("demo-team-send-%d", i)
+		for _, line := range []journalLine{
+			{Type: "message", Role: "assistant", ToolCalls: []ai.ToolCall{call(callID, "team_send", map[string]any{"team": primary.ID, "to": member.Handle, "text": text})}},
+			answer(callID, "Sent ("+teamstore.ThreadNumber(id)+")."),
+			{Type: "message", Role: "user", Content: fmt.Sprintf("Team traffic in %q\nfrom @%s %s: %s", primary.Name, member.Handle, teamstore.ThreadNumber(replyID), replyText)},
+		} {
+			if err := appendJSONL(members[0].File, line); err != nil {
+				return err
+			}
+		}
+		postID := fmt.Sprintf("demo-team-post-%d", i)
+		for _, line := range []journalLine{
+			{Type: "message", Role: "user", Content: fmt.Sprintf("Team traffic in %q\n◆ from manager %s: %s", primary.Name, teamstore.ThreadNumber(id), text)},
+			{Type: "message", Role: "assistant", ToolCalls: []ai.ToolCall{call(postID, "team_post", map[string]any{"text": replyText})}},
+			answer(postID, "Posted as "+teamstore.ThreadNumber(replyID)+"."),
+		} {
+			if err := appendJSONL(member.File, line); err != nil {
+				return err
+			}
+		}
+	}
+	_, err := teamstore.Raise(root, teamstore.Packet{Team: teamstore.Person, Origin: primary.ID, RaisedBy: "manager", Kind: teamstore.PacketQuestion,
+		Question: "Which layout should we review first?", Options: []teamstore.Option{
+			{ID: "wide", Label: "Wide terminal", Consequence: "Review the full member grid and interaction table."},
+			{ID: "narrow", Label: "Narrow terminal", Consequence: "Review scrolling and access to every member."},
+		}})
+	return err
+}

cmd/codeaf-demo-home/seed_test.go

@@ -25,6 +25,7 @@ import (
 	"github.com/Agent-Field/codeaf/internal/session"
 	"github.com/Agent-Field/codeaf/internal/standing"
 	"github.com/Agent-Field/codeaf/internal/store"
+	teamstore "github.com/Agent-Field/codeaf/internal/teams"
 )
 
 func TestTheDemoHomeFillsEveryPlace(t *testing.T) {
@@ -109,6 +110,59 @@ func TestTheDemoHomeFillsEveryPlace(t *testing.T) {
 		}
 	}
 
+	// The Teams fixture must resolve every conversation and interaction door,
+	// while keeping historical notes from waking an agent during a review.
+	teams, err := teamstore.Load(filepath.Join(dir, ".codeaf"))
+	if err != nil || len(teams.Teams) != 3 {
+		t.Fatalf("read the three demo teams: %+v, %v", teams, err)
+	}
+	if len(teams.ClosedTeams()) != 1 {
+		t.Fatal("demo must include one closed team so its category can be reviewed")
+	}
+	memberships := map[string]int{}
+	for _, team := range teams.Teams {
+		if team.Manager == "" || team.Settings.Wake == nil || *team.Settings.Wake {
+			t.Fatalf("team has no manager or can wake historical work: %+v", team)
+		}
+		for _, member := range team.Members {
+			if !team.Closed() {
+				memberships[member.Key]++
+			}
+			if _, err := os.Stat(member.File); err != nil {
+				t.Fatalf("team member has no conversation: %v", err)
+			}
+		}
+		if len(team.Members) == 6 {
+			traffic, err := teamstore.ReadTraffic(filepath.Join(dir, ".codeaf"), team.ID, "", 200)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var notes []teamstore.Entry
+			for _, entry := range traffic {
+				if entry.Kind == teamstore.KindNote {
+					notes = append(notes, entry)
+				}
+			}
+			if len(notes) != 48 {
+				t.Fatalf("demo has %d interaction notes, want 48", len(notes))
+			}
+			for i := 1; i < len(notes); i += 2 {
+				if notes[i].Answers != notes[i-1].ID {
+					t.Fatalf("demo reply is disconnected: %+v", notes[i])
+				}
+			}
+		}
+	}
+	shared := 0
+	for _, count := range memberships {
+		if count > 1 {
+			shared++
+		}
+	}
+	if shared != 2 {
+		t.Fatalf("demo has %d shared conversations, want two", shared)
+	}
+
 	// ── the tasks place: one running row, and landed work behind it ───────────
 	index, running, landed := 0, 0, 0
 	for _, project := range world.Projects {

cmd/codeaf/chatv3_host.go

@@ -917,6 +917,15 @@ func hostOptions(fleet *engineFleet, welcome remote.Welcome, pick bool) (tui3.Op
 		options.SubscribeServiceModels = listing.registerServiceNotice
 		options.ApplyModelSources = shelf.setSources
 	}
+	if welcome.TaskDelete {
+		options.DeleteTask = func(file, id string) error {
+			if err := client.DeleteTask(file, id); err != nil {
+				return err
+			}
+			world.fetch()
+			return nil
+		}
+	}
 	if !fleet.canBeside() {
 		// A DOOR THAT CANNOT DIAL AGAIN REALLY DOES HOLD ONE CONVERSATION AT A
 		// TIME, and says so ([tui3.Options.SharedAgent]) rather than letting
@@ -948,6 +957,27 @@ func hostOptions(fleet *engineFleet, welcome remote.Welcome, pick bool) (tui3.Op
 	// there is exactly one door and no road on which a swap can still happen.
 	options.Start = fleet.start
 	options.Open = fleet.open
+	if welcome.ConversationDelete {
+		options.DeleteConversation = func(file string, choices map[string]string, affected map[string][]string) error {
+			if err := client.DeleteConversation(file, choices, affected); err != nil {
+				return err
+			}
+			world.mu.Lock()
+			defer world.mu.Unlock()
+			for i := range world.held.Projects {
+				rows := world.held.Projects[i].Sessions
+				kept := rows[:0:0]
+				for _, row := range rows {
+					if row.Transcript != file {
+						kept = append(kept, row)
+					}
+				}
+				world.held.Projects[i].Sessions = kept
+			}
+			return nil
+		}
+	}
+
 	return options, settings
 }
 

cmd/codeaf/chatv3_host_teams.go

@@ -38,13 +38,14 @@ type hostTeams struct {
 	defaults func() (teamstore.Defaults, error)
 	// applyDefault writes one `teams.` row ([remote.Welcome.TeamSettings]).
 	// Nil leaves the settings Teams tab read-only.
-	applyDefault func(key, raw string) (teamstore.Defaults, error)
-	packets      func(scope, stamp string) (remote.PacketsReading, error)
-	raise        func(p teamstore.Packet) (teamstore.Packet, error)
-	decide       func(id, by, decision, reason string) (teamstore.Packet, error)
-	escalate     func(id, by, to, reason string) (teamstore.Packet, error)
-	spend        func(team, day, stamp string) (remote.SpendReading, error)
-	deleteOne    func(team string) (remote.DeleteTeamReply, error)
+	applyDefault  func(key, raw string) (teamstore.Defaults, error)
+	packets       func(scope, stamp string) (remote.PacketsReading, error)
+	raise         func(p teamstore.Packet) (teamstore.Packet, error)
+	decide        func(id, by, decision, reason string) (teamstore.Packet, error)
+	escalate      func(id, by, to, reason string) (teamstore.Packet, error)
+	spend         func(team, day, stamp string) (remote.SpendReading, error)
+	deleteOne     func(team string) (remote.DeleteTeamReply, error)
+	deleteChecked func(team string, expected []string) (remote.DeleteTeamReply, error)
 	// The wrap-up's two doors, nil when the engine does not answer them
 	// ([remote.Welcome.WrapUp]).
 	wrapUp        func(team, text string) error
@@ -76,8 +77,13 @@ func newHostTeams(far hostFar, delegation, wrapUp, settings bool) *hostTeams {
 	}
 	if delegation {
 		c := far.client
+		if c.Welcome().ConversationDelete {
+			h.deleteChecked = func(team string, expected []string) (remote.DeleteTeamReply, error) {
+				return c.TeamsDelete(team, expected)
+			}
+		}
 		h.defaults, h.packets, h.raise = c.TeamsDefaults, c.TeamsPackets, c.TeamsRaise
-		h.decide, h.escalate, h.spend, h.deleteOne = c.TeamsDecide, c.TeamsEscalate, c.TeamsSpend, c.TeamsDelete
+		h.decide, h.escalate, h.spend, h.deleteOne = c.TeamsDecide, c.TeamsEscalate, c.TeamsSpend, func(team string) (remote.DeleteTeamReply, error) { return c.TeamsDelete(team) }
 		if wrapUp {
 			h.wrapUp, h.acceptClosing = c.TeamsWrapUp, c.TeamsAcceptClosing
 		}
@@ -96,6 +102,9 @@ func hostTeamsSeam(far hostFar, welcome remote.Welcome) tui3.TeamsSeam {
 	if far.client == nil || !welcome.Teams {
 		return tui3.TeamsSeam{}
 	}
+	if welcome.TeamMembershipVersion != remote.TeamMembershipVersion {
+		return tui3.TeamsSeam{}
+	}
 	return newHostTeams(far, welcome.Delegation, welcome.WrapUp, welcome.TeamSettings).seam()
 }
 
@@ -112,6 +121,9 @@ func (h *hostTeams) seam() tui3.TeamsSeam {
 	}
 	s.Defaults, s.Raise, s.Decide, s.Escalate = h.defaults, h.raise, h.decide, h.escalate
 	s.Packets, s.Spend, s.Delete = h.readPackets, h.readSpend, h.forget
+	if h.deleteChecked != nil {
+		s.DeleteChecked = h.forgetChecked
+	}
 	if h.wrapUp != nil && h.acceptClosing != nil {
 		s.WrapUp, s.AcceptClosing = h.wrapUp, h.closeOnReport
 	}
@@ -275,3 +287,14 @@ func cloneTeams(teams []teamstore.Team) []teamstore.Team {
 	}
 	return out
 }
+
+func (h *hostTeams) forgetChecked(team string, expected []string) ([]string, error) {
+	reply, err := h.deleteChecked(team, expected)
+	if err != nil {
+		return nil, err
+	}
+	if _, _, _, err := h.readSince("", h.reservedHues()); err != nil {
+		return reply.Gone, err
+	}
+	return reply.Gone, nil
+}