UX changes: home navigation and consistent message-box controls

PERF.md

@@ -2532,3 +2532,17 @@ plus at most two 400-byte neighbours on each side. They do not read whole
 transcripts or invoke an embedding model. Search tokenization accepts at most
 32 Unicode word/number tokens, quoted as FTS data. History access inherited by
 tasks grants reads only and introduces no background memory calls or writes.
+
+## Home conversation list budget
+
+Home's conversation list is bounded by `tui3.tabsCap` (32 open tabs) plus
+`tui3.homeClosedLimit` (3 closed conversations). It replaces the ten-row saved-history
+budget. A short frame folds what cannot fit; metadata comes from Home's cached world
+reading. Tab membership changes rebuild the list without rereading the filesystem.
+
+### One conversation name (2026-09-20)
+
+Conversation naming requests one 5–8 word phrase. The former two-word/32-byte
+short-label cap is removed; `titleLimit` remains 80 bytes for the only stored title.
+`titleClip`, the 20-second ask window and the two-minute naming window are unchanged.
+Home and tab widths truncate that same title with three dots at render time.

cmd/codeaf/chatv3.go

@@ -397,14 +397,6 @@ func openChatV3(name string, args []string, pickSession bool) error {
 	// only model it can be about: --reasoning names a strength, not a model, and
 	// the level is kept per model from here on (internal/session's agent.go).
 	agent.SetReasoning(level)
-	// AND THE RUNG THIS CONVERSATION WAS LEFT ON. It is the meta.json half of
-	// the same law the model row keeps (internal/session's Meta): a person who
-	// dialled a conversation deeper, worked in it and came back found it at the
-	// install's default as though they had chosen nothing. Absence sets nothing
-	// and stamps nothing, so a conversation nobody has dialled is unchanged.
-	if saved := strings.TrimSpace(v3SavedEffort(cfg.Place)); saved != "" {
-		agent.SetConversationEffort(saved)
-	}
 	proc.track(agent)
 	// EVERY CONVERSATION THIS PROCESS OPENED, CLOSED HOWEVER THE SURFACE RETURNS.
 	// Close is the surface's to call — /quit and ctrl+c both go through it — but
@@ -1065,6 +1057,14 @@ func openV3Launch(proc *v3Process, opts v3Options) (*v3Launch, error) {
 	// never a second policy.
 	cfg.Unattended = opts.Yolo
 	cfg.Interactive = opts.Interactive
+	if !opts.Interactive {
+		gate := v3ApprovalGate{workspace: cfg.Workspace, profileDir: settings.ProfileDir, headless: true}
+		cfg.ApprovalGate = gate
+		cfg.ApprovalPolicy, cfg.Guardian, err = gate.Build(cfg.ApprovalPosture)
+		if err != nil {
+			return nil, err
+		}
+	}
 	cfg.Budget = opts.Budget
 	// AND THE ACCOUNTS MANAGER IS THE PROCESS'S, not this launch's. Governance
 	// leaves the field empty for exactly this reason: an account connected on
@@ -1153,6 +1153,21 @@ func v3SavedEffort(place session.Place) string {
 	return meta.Effort
 }
 
+// v3SavedApproval is the posture this conversation last set on its own gate,
+// read back off its folder on [v3SavedEffort]'s terms: "" for a fresh
+// conversation, a build before the field existed, or a file that does not read.
+func v3SavedApproval(place session.Place) string {
+	dir := strings.TrimSpace(place.Dir)
+	if dir == "" {
+		return ""
+	}
+	meta, err := session.LoadMeta(dir)
+	if err != nil {
+		return ""
+	}
+	return meta.Approval
+}
+
 // v3TalkModel is which model this conversation opens on, and the order is the
 // whole content: what the person named on the command line, then what they
 // last chose and it was written down (internal/config's chatmodel.go), then
@@ -1238,8 +1253,46 @@ func v3Connections(manager *connect.Manager) tui3.Connections {
 // cannot be shown a fuel gate (engine.go) — and a door deciding that for itself
 // would be this file guessing who is watching.
 func openV3Agent(cfg session.Config, workspace string, open func(session.Config) (*session.Agent, error)) (*session.Agent, session.Config, string, error) {
-	agent, err := open(cfg)
+	// Restore the gate before construction, so restored work cannot start behind
+	// the profile default. Return the launch config unchanged: a subsequent new
+	// conversation must not inherit this one's saved override.
+	restored := cfg
+	savedEffort := strings.TrimSpace(v3SavedEffort(cfg.Place))
+	restoredPosture := ""
+	if saved := strings.TrimSpace(v3SavedApproval(cfg.Place)); saved != "" && cfg.ApprovalPosture == "" && cfg.ApprovalGate != nil {
+		valid := false
+		for _, posture := range session.ApprovalPostures {
+			if saved == posture {
+				valid = true
+			}
+		}
+		if !valid {
+			saved = session.PostureAsk
+		}
+		build := saved
+		if saved == session.PostureAuto {
+			build = ""
+		}
+		policy, guardian, err := cfg.ApprovalGate.Build(build)
+		if err != nil {
+			return nil, cfg, "", fmt.Errorf("restore conversation approvals: %w", err)
+		}
+		if policy == nil {
+			return nil, cfg, "", errors.New("restore conversation approvals: rules unavailable")
+		}
+		restored.ApprovalPolicy, restored.Guardian, restoredPosture = policy, guardian, saved
+	}
+	agent, err := open(restored)
 	if err == nil {
+		if restoredPosture != "" {
+			if err := agent.SetApprovalPosture(restoredPosture); err != nil {
+				_ = agent.Close()
+				return nil, cfg, "", fmt.Errorf("restore conversation approvals: %w", err)
+			}
+		}
+		if savedEffort != "" {
+			agent.SetConversationEffort(savedEffort)
+		}
 		return agent, cfg, "", nil
 	}
 	if !errors.Is(err, session.ErrSessionLocked) {
@@ -1439,6 +1492,15 @@ func applyV3Governance(cfg session.Config, profileDir string, yolo, oneModel boo
 	// a repository may state are still the rules — it can say what to ask about;
 	// it cannot say who answers.
 	cfg.Guardian = config.GuardianEnabledAt(profileDir)
+	// AND THE DOOR THE CONVERSATION MOVES ITS OWN GATE THROUGH, over the same
+	// rows (chatv3_approval.go's [v3ApprovalGate]). --yolo is handed down as the
+	// posture an untouched conversation starts at rather than only as the
+	// policy it starts on, so the seam can say what it is and the wheel can
+	// walk away from it (internal/session's approvalposture.go).
+	cfg.ApprovalGate = v3ApprovalGate{workspace: workspace, profileDir: profileDir}
+	if yolo {
+		cfg.ApprovalPosture = session.PostureAllow
+	}
 	cfg.TaskAutoApproveSeconds = config.TaskAutoApproveAt(profileDir)
 	cfg.BashBackgroundAfterSeconds = config.BashBackgroundAfterAt(profileDir)
 	// Which model the work that leaves this conversation runs on, PROFILE-ONLY
@@ -1658,12 +1720,25 @@ func v3SurfacePosture(yolo bool) string {
 // `bash:prompt` still gets asked about bash: the flag is "stop asking me about
 // the ordinary things", not "forget what I wrote down".
 func v3Policy(workspace, profileDir string, yolo bool) (*approval.Policy, error) {
-	mode, err := config.ProjectStringAt(workspace, profileDir, config.KeyToolApprovalMode)
-	if err != nil {
-		return nil, err
-	}
 	if yolo {
-		mode = string(approval.ActionAllow)
+		return v3PolicyMode(workspace, profileDir, string(approval.ActionAllow))
+	}
+	return v3PolicyMode(workspace, profileDir, "")
+}
+
+// v3PolicyMode is [v3Policy] with the blanket answer named outright: mode
+// replaces the `tools.approvalMode` row for this build and "" reads the row.
+// It is the one function every posture goes through — the flag's forced allow,
+// a conversation's own wheel (chatv3_approval.go's [v3ApprovalGate]) and the
+// ordinary launch — so the exceptions, the shell rules and the floor cannot
+// differ between them.
+func v3PolicyMode(workspace, profileDir, mode string) (*approval.Policy, error) {
+	if mode == "" {
+		row, err := config.ProjectStringAt(workspace, profileDir, config.KeyToolApprovalMode)
+		if err != nil {
+			return nil, err
+		}
+		mode = row
 	}
 	raw := map[string]any{"default": mode}
 	text, err := config.ProjectStringAt(workspace, profileDir, config.KeyToolApprovals)

cmd/codeaf/chatv3_approval.go

@@ -21,6 +21,96 @@ type v3Gate interface {
 	SetApprovalPolicy(policy *approval.Policy)
 }
 
+// v3Rebuilder is the newer door on the same agent: a session that knows its
+// own posture rebuilds the gate FOR that posture (internal/session's
+// approvalposture.go), so a rule banked inside a conversation walked to allow
+// lands on an allow gate. [refreshV3Policy] and [applyV3Approvals] prefer it
+// and keep the plain push for a gate that does not have it.
+type v3Rebuilder interface {
+	ApprovalDial() bool
+	RebuildApprovalGate() error
+}
+
+// v3Rebuilt asks the agent to rebuild its own gate where it can, and reports
+// whether it could. AN AGENT WITH THE METHODS AND NO DOOR IS NOT REBUILT HERE:
+// a session assembled without [session.Config.ApprovalGate] — a test's, a
+// worker's — refuses the rebuild, and a refusal that silenced the plain push
+// left a banked rule reaching nobody's gate (the person was asked twice for
+// one command). So the door is asked first, and only a session that has one
+// takes this road.
+func v3Rebuilt(agent v3Gate) (bool, error) {
+	rebuilder, ok := agent.(v3Rebuilder)
+	if !ok || !rebuilder.ApprovalDial() {
+		return false, nil
+	}
+	return true, rebuilder.RebuildApprovalGate()
+}
+
+// v3ApprovalGate is the door a conversation moves its own gate through
+// ([session.ApprovalGate]): the same three rows, the same project layer, the
+// same floors as the launch, asked for by posture instead of by flag.
+//
+// THE POSTURE IS A WORD FOR A PAIR. The ladder folds the guardian row into the
+// mode (internal/session's approvalposture.go says why), so `ask` is prompt
+// with the guardian stood down, `guardian` is prompt with it up, and `allow`
+// and `deny` are the row's own words with the guardian irrelevant. An empty
+// posture is the rows exactly as they stand — which is what an untouched
+// conversation runs at and what `auto` hands back to.
+type v3ApprovalGate struct {
+	workspace, profileDir string
+	headless              bool
+}
+
+func (g v3ApprovalGate) Build(posture string) (*approval.Policy, bool, error) {
+	mode := ""
+	guardian := config.GuardianEnabledAt(g.profileDir)
+	switch posture {
+	case session.PostureAsk:
+		mode, guardian = string(approval.ActionPrompt), false
+	case session.PostureGuardian:
+		mode, guardian = string(approval.ActionPrompt), true
+	case session.PostureAllow:
+		mode, guardian = string(approval.ActionAllow), false
+	case session.PostureDeny:
+		mode, guardian = string(approval.ActionDeny), false
+	}
+	if mode == "" && g.headless {
+		var err error
+		mode, err = config.HeadlessToolApprovalModeAt(g.workspace, g.profileDir)
+		if err != nil {
+			return nil, false, err
+		}
+	}
+	policy, err := v3PolicyMode(g.workspace, g.profileDir, mode)
+	if err != nil {
+		return nil, false, err
+	}
+	return policy, guardian, nil
+}
+
+// Standing is the rows as they stand, said in the ladder's words. An unreadable
+// mode row reads as the strictest answer it could be, which is internal/config's
+// own law for that row and the one direction a garbled setting may be wrong in.
+func (g v3ApprovalGate) Standing() string {
+	mode, err := config.ProjectStringAt(g.workspace, g.profileDir, config.KeyToolApprovalMode)
+	if g.headless {
+		mode, err = config.HeadlessToolApprovalModeAt(g.workspace, g.profileDir)
+	}
+	if err != nil {
+		mode = string(approval.ActionPrompt)
+	}
+	switch mode {
+	case string(approval.ActionAllow):
+		return session.PostureAllow
+	case string(approval.ActionDeny):
+		return session.PostureDeny
+	}
+	if config.GuardianEnabledAt(g.profileDir) {
+		return session.PostureGuardian
+	}
+	return session.PostureAsk
+}
+
 // The consent card's door back to disk: where "always" is written down.
 //
 // It is a PAIR — one seam for a tool, one for a shell command — handed to the
@@ -114,6 +204,9 @@ func bankBashApproval(agent v3Gate, workspace, profileDir string, yolo bool) fun
 // names the next session rather than claiming the line is already gone.
 func applyV3Approvals(agent v3Gate, workspace, profileDir string, yolo bool) func() error {
 	return func() error {
+		if rebuilt, err := v3Rebuilt(agent); rebuilt {
+			return err
+		}
 		policy, err := v3Policy(workspace, profileDir, yolo)
 		if err != nil {
 			return err
@@ -157,6 +250,9 @@ func refreshV3Policy(agent v3Gate, workspace, profileDir string, yolo bool) {
 	if agent == nil {
 		return
 	}
+	if rebuilt, _ := v3Rebuilt(agent); rebuilt {
+		return
+	}
 	policy, err := v3Policy(workspace, profileDir, yolo)
 	if err != nil {
 		return

cmd/codeaf/chatv3_approvalfloor_test.go

@@ -166,7 +166,7 @@ func TestTheSecondConversationKeepsTheLaunchsPosture(t *testing.T) {
 // A rebuild that cannot read the rows leaves the launch's gate in place. The
 // answer to "I could not read the rules" is never a session with no rules.
 func TestAnUnreadableRowLeavesTheSecondConversationOnTheLaunchsGate(t *testing.T) {
-	launch, err := applyV3Governance(session.Config{Model: "m"}, t.TempDir(), false, false)
+	launch, err := applyV3Governance(session.Config{Model: "m"}, v3Profile(t, map[string]any{"tools.approvalMode": "prompt"}), false, false)
 	if err != nil {
 		t.Fatalf("the launch did not load: %v", err)
 	}

cmd/codeaf/chatv3_at.go

@@ -168,6 +168,7 @@ func openChatV3At(launch atLaunch) error {
 	defer func() { closeLink() }()
 
 	client, err := remote.Dial(tunnel, name, remote.Hello{
+		Headless:  launch.once != "",
 		Workspace: workspace,
 		Session:   launch.session,
 		Model:     launch.model,

cmd/codeaf/chatv3_host.go

@@ -494,7 +494,9 @@ func openChatV3Host(launch hostLaunch) error {
 	if launch.pick && launch.once != "" {
 		return fmt.Errorf(`codeaf resume opens the session picker; for one headless message use: codeaf chat --host %s --once "text"`, dest)
 	}
-	link, err := dialEngine(dest, workspace, launchHello(launch.session, launch.model, launch.level))
+	hello := launchHello(launch.session, launch.model, launch.level)
+	hello.Headless = launch.once != ""
+	link, err := dialEngine(dest, workspace, hello)
 	if err != nil {
 		return err
 	}

cmd/codeaf/chatv3_lanes_test.go

@@ -100,7 +100,7 @@ func TestTheLanesOverAConnectionAreTheOnesTheWireSaysItCarries(t *testing.T) {
 // is built INTO the session rather than switched on after it opened.
 func TestTheEngineBuildsTheSessionWithTheShapeTheHelloCarried(t *testing.T) {
 	plain := engineLaunchOptions(remote.Hello{Workspace: "/srv/app"}, "/srv/app", "")
-	if plain.Yolo || plain.NoCompact || plain.OneModel || plain.Budget.Set() || plain.Interactive {
+	if plain.Yolo || plain.NoCompact || plain.OneModel || plain.Budget.Set() || !plain.Interactive {
 		t.Fatalf("a hello with no shape built %+v", plain)
 	}
 	shaped := engineLaunchOptions(remote.Hello{

cmd/codeaf/chatv3_local.go

@@ -176,6 +176,7 @@ func openChatV3Local(launch localLaunch) error {
 	// front of a path, and `another window` where a connection would name a
 	// host.
 	hello := remote.Hello{
+		Headless:  launch.once != "",
 		Workspace: launch.workspace,
 		Session:   launch.session,
 		Model:     launch.model,

cmd/codeaf/chatv3_local_test.go

@@ -350,7 +350,7 @@ func TestAConnectedModelServiceIsLiveInTheRunningEngineConversation(t *testing.T
 // the answer releases the call. The next matching command therefore runs
 // without asking the person a second time.
 func TestABankedBashRuleReachesTheRunningEngineBeforeTheAnswer(t *testing.T) {
-	profileDir := t.TempDir()
+	profileDir := v3Profile(t, map[string]any{"tools.approvalMode": "prompt"})
 	workspace := t.TempDir()
 	command := "printf banked-rule-probe"
 	server := consentSource(t, command)