One task page for every task: a run's task opens the real task room

docs/changes/unreleased/1485-one-task-page.md

@@ -0,0 +1,18 @@
+---
+kind: changed
+title: Every task opens the one task room, on either engine
+pr: 1485
+surface: [chat, docs]
+invalidates:
+  - A run's task opened a separate store-backed page (taskSheetPlan, taskPlanFrame); it now opens the task room, read from the store.
+  - The run's page had no transcript or work tab; every task room now has both, switched with tab over an empty box.
+  - The run's page took p to hold a part and cancelled a part directly; in the room p is a letter and x raises the stop card.
+  - Tokens and the model were said not to be in the plan store; the room's head reads both from the spend ledger.
+  - The tasks place's enter and the run's tab opened the plan page; both open the task room now.
+---
+
+A task on the run engine now opens the same task room as any other task. Its transcript is
+the worker's steps drawn as the room's own calls, its work tab is the run's working copy
+difference, its box leaves a note on the task, and `x` stops it. The head shows the model
+and tokens when the store's ledger records them. Every task room gains `transcript` and
+`work` tabs.

internal/e2e/tui_e2e_test.go

@@ -2204,7 +2204,7 @@ func testTaskOnTheDefaultBelt(t *testing.T) {
 
 // taskOnTheRunEngine is the body the two subtests above share: launch with the
 // key and whatever belt words the caller names, put one `/task` on the run
-// engine, and read the run off the tasks place, the plan page and the thread.
+// engine, and read the run off the tasks place, the task's room and the thread.
 func taskOnTheRunEngine(t *testing.T, rigName string, beltWords ...string) {
 	home := newHome(t, nil)
 	ws := newWorkspace(t, "runws", false)
@@ -2235,15 +2235,12 @@ func taskOnTheRunEngine(t *testing.T, rigName string, beltWords ...string) {
 	running := planRowWaitsToWear(t, r, 40*time.Second, runRowWord, say(t, "planRunningWord"))
 	t.Logf("the run on the tasks place, while a worker holds its task:\n%s", running)
 
-	// ── the page mid-run: the live step at the live edge ────────────────────
+	// ── the room mid-run ────────────────────────────────────────────────────
 	//
-	// ENTER OPENS THE PLAN PAGE, and while a worker holds the task the page
-	// follows its live edge: the step being run right now is drawn ONE STEP EARLY,
-	// with the running glyph beside the command and the call's own clock under it
-	// (docs/design/worker-harness/SURFACE.md §4, Cell 3; taskplan.go's
-	// taskPlanBody). It is read here, before the root lands, because the live step
-	// is gone the moment its command ends — the page after the landing is the
-	// settled page the section below reads.
+	// ENTER OPENS THE TASK'S ROOM, the one page every task opens, and while a
+	// worker holds the task the room follows it on its own beat (internal/tui3's
+	// planroom.go). It is read here, before the root lands; the room after the
+	// landing is the settled room the section below reads.
 	//
 	// AND THE CURSOR IS MOVED ONTO THE ROW FIRST ([tasksPlaceRunRow]). Enter on
 	// the conversation row is the door into the conversation and always was, so
@@ -2252,29 +2249,27 @@ func taskOnTheRunEngine(t *testing.T, rigName string, beltWords ...string) {
 	// conversation too.
 	tasksPlaceRunRow(t, r)
 	r.keys("Enter")
-	// THE PAGE COMING UP IS THE ASSERTION AND THE LIVE STEP IS AN OBSERVATION,
-	// and the two are separated here because only one of them is a fact about
-	// the surface. That the press over the row opens the STORE'S page rather
-	// than a room is true every time, and the page's own note box says it is
-	// the page. Which command a worker happens to be part-way through when the
-	// key lands is a moment: this brief is four steps and about half a minute,
-	// so a page opened a second after the last one ends is an honest page of a
-	// task that has finished — [rig.glimpse]'s own bargain, which never fails
-	// on a thing that is only on screen while work runs. Asserting it made a
-	// red out of a fast run and said nothing about any defect.
-	page := r.waitFor(40*time.Second, say(t, "planNoteBoxWord"))
-	t.Logf("the page the press over the run's row opened:\n%s", page)
+	// THE ROOM COMING UP IS THE ASSERTION: its two tabs are there whatever state
+	// the task is in. The note box's own words are there only while the task can
+	// still take a note, and which command a worker happens to be part-way
+	// through when the key lands is a moment, so both are only logged.
+	page := r.waitFor(40*time.Second, say(t, "roomTabsWords"))
+	t.Logf("the room the press over the run's row opened:\n%s", page)
+	if box, saw := r.glimpse(2*time.Second, say(t, "planNoteBoxWord")); saw {
+		t.Logf("the room's box takes a note while the task runs:\n%s", box)
+	} else {
+		t.Logf("the task had ended before its room opened, so its box names another door")
+	}
 	if live, sawLive := r.glimpse(15*time.Second, say(t, "planLiveGlyph")); sawLive {
-		if !strings.Contains(live, say(t, "planLiveClockWord")) {
-			t.Errorf("the plan page's live line has no clock under it (%q):\n%s",
-				say(t, "planLiveClockWord"), live)
-		}
-		t.Logf("the plan page mid-run, carrying the live step:\n%s", live)
+		t.Logf("the room mid-run, carrying the live step:\n%s", live)
 	} else {
-		t.Logf("the run finished before a live step could be caught on the page, which is this " +
+		t.Logf("the run finished before a live step could be caught in the room, which is this " +
 			"brief on a fast worker and not a defect")
 	}
+	// `esc` LEAVES THE ROOM FOR THE CONVERSATION, the way every room does, so
+	// the place is opened again to watch the row land.
 	r.keys("Escape")
+	openTasksPlace(t, r)
 
 	done := planRowWaitsToWear(t, r, runPatience, runRowWord, say(t, "planDoneWord"))
 	t.Logf("the run on the tasks place once its root landed:\n%s", done)
@@ -2295,20 +2290,16 @@ func taskOnTheRunEngine(t *testing.T, rigName string, beltWords ...string) {
 		t.Errorf("the landing does not name the branch the run's work is on (%q):\n%s", branch, landed)
 	}
 
-	// ── the page one row opens ──────────────────────────────────────────────
+	// ── the room one row opens ──────────────────────────────────────────────
 	//
-	// ENTER OVER THE ROW OPENS THE STORE'S OWN PAGE — the description the worker
-	// was given, the notes left on the task, and the trajectory: one line per
-	// command the worker ran, and the run's own finish among them. `esc` backs out
-	// one layer to the list, the card's own bargain.
+	// ENTER OVER THE ROW OPENS THE TASK'S ROOM, read through the store: the
+	// description the worker was given, the notes left on the task, and the
+	// trajectory as the room's own call rows. `esc` leaves for the conversation.
 	openTasksPlace(t, r)
 	tasksPlaceRunRow(t, r)
 	r.keys("Enter")
-	// THE PAGE IS READ BY TWO OF ITS OWN WORDS, and neither is the model's. The
-	// note box stands on this page and on nothing else, and the head's figures
-	// are the store's count of the steps its worker took and what they cost —
-	// so the pair says the press opened THE STORE'S PAGE and not the room a
-	// record row opens, which is the whole of what this scenario came to prove.
+	// THE ROOM IS READ BY ITS OWN WORDS, and not by the model's: the
+	// room's two tabs, which every task's room draws on either engine.
 	//
 	// WHICH COMMANDS ARE ON IT IS THE WORKER'S BUSINESS. The finish is the
 	// worker's own `plandb done` when the worker writes one, and the RUN's when
@@ -2317,17 +2308,18 @@ func taskOnTheRunEngine(t *testing.T, rigName string, beltWords ...string) {
 	// page carried `echo`, `cat` and the run's own ending note. So the finish
 	// command is observed and logged, never waited out: asserting it made a red
 	// out of a model's choice and said nothing about the surface.
-	stored := r.waitFor(40*time.Second, say(t, "planNoteBoxWord"), say(t, "planStepsSpend"))
-	t.Logf("the page the run's row opens, with the store's own figures on it:\n%s", stored)
+	stored := r.waitFor(40*time.Second, say(t, "roomTabsWords"))
+	t.Logf("the room the run's row opens:\n%s", stored)
 	if finish, saw := r.glimpse(5*time.Second, say(t, "planFinishCommand")); saw {
 		t.Logf("and this worker wrote its own finish into the trajectory:\n%s", finish)
 	} else {
 		t.Logf("this worker left the ending to the run, so no %q step is on the page",
 			say(t, "planFinishCommand"))
 	}
 	r.keys("Escape")
-	back := r.waitFor(30*time.Second, say(t, "planDoneWord"))
-	t.Logf("esc backed out of the page to the list:\n%s", back)
+	openTasksPlace(t, r)
+	back := planRowWaitsToWear(t, r, 30*time.Second, runRowWord, say(t, "planDoneWord"))
+	t.Logf("the list, after esc left the room:\n%s", back)
 	r.quit()
 }
 

internal/e2e/tuiwords_test.go

@@ -637,39 +637,38 @@ var tuiWords = map[string]tuiWord{
 		source: "plandb done",
 		pkg:    "internal/session",
 		why: "the command a bash-belt worker finishes its store task with, recorded in the task's own " +
-			"trajectory and drawn as a step line on the plan page (taskplan.go's taskPlanBody reads " +
+			"trajectory and drawn as a call row in the task's room (planroom.go reads " +
 			"PlanTaskPage.Steps). THE PAGE DOES NOT SPELL IT — the worker runs it — so the gate looks where " +
 			"it is written: internal/session's plandb_plan.go, the sentence that teaches the finish. " +
 			"IT IS OBSERVED AND NEVER WAITED OUT, because whether it is on a page is the WORKER'S " +
 			"choice: the run writes the ending itself for a task whose worker stopped calling tools " +
 			"without writing one (internal/run's worker.go), which a small brief on a fast model " +
-			"regularly is. What the suite asserts about that page instead is that it is the store's " +
-			"page at all — planNoteBoxWord and planStepsSpend, two words no room draws",
+			"regularly is. What the suite asserts about that room instead is that it is the task's " +
+			"room at all: roomTabsWords",
 	},
 	"planNoteBoxWord": {
 		screen: "a note for this task",
-		why: "the plan page's own note box (taskplan.go's taskPlanNoteWord), and the one word on it " +
-			"that is there whatever state the task is in. It is what says the press over a run's row " +
-			"opened THE STORE'S PAGE rather than a room — the assertion that defect #1359 was about — " +
-			"where the live step beside it is a moment and is only ever observed",
+		why: "the note box a run's task takes its notes in (taskplan.go's taskPlanNoteWord, drawn as " +
+			"the task room's steer box by room.go) while the task can still take a note. A task that has " +
+			"ended names another door in its box, so the suite only observes this word; what it asserts " +
+			"about the room is roomTabsWords",
+	},
+	"roomTabsWords": {
+		screen: "transcript · work",
+		source: "transcript",
+		why: "the two tabs every task's room draws on its trail, on either engine (roomtabs.go): the " +
+			"transcript and the work the task changed. A run's task opens the same room as any other " +
+			"task, so the tabs are what say the press opened the room and not a page of its own",
 	},
 	"planLiveGlyph": {
 		screen: tokens.GlyphStepRunning,
 		pkg:    tokensPkg,
-		why: "the mark the plan page leads the step it is running RIGHT NOW with, where the recorded " +
-			"steps lead with their number (taskplan.go's taskPlanBody, drawn through palette.glyph so the " +
-			"tier picks the rune rather than a literal in the surface). It is tokens.GStepRunning — one " +
+		why: "the mark the task's room leads the step it is running RIGHT NOW with (planroom.go draws " +
+			"the store's live step as a call in flight, through palette.glyph so the tier picks the rune " +
+			"rather than a literal in the surface). It is tokens.GStepRunning — one " +
 			"shape for one state, the same rune `working` wears — so the gate looks where the rune is " +
 			"spelled, and this suite sees the plain tier its throwaway profile pins",
 	},
-	"planLiveClockWord": {
-		screen: "running ",
-		source: "running ",
-		why: "the call's own clock, said under the live step on the plan page: the same ten-second " +
-			"count the rail keeps (taskplan.go's taskPlanBody reads PlanTaskPage.Live and taskToolFloor " +
-			"gates it, the 10-second clock the rail already keeps). It is the page's word, so the gate " +
-			"looks for it in the surface",
-	},
 
 	// ── the run's plan row, on the live edge (c185, SURFACE.md §2A/§3) ────────
 	//

internal/enginehost/enginehost_test.go

@@ -674,3 +674,67 @@ func TestHostedAgentReadsSeededPlanTasksEndToEnd(t *testing.T) {
 	}
 	t.Fatalf("PlanTasks over host = %+v, want seeded real-store row", rows)
 }
+
+// THE TASK PAGE'S MODEL IS THE LEDGER'S, and it has to cross the host: the
+// room head reads it off the page the engine served, and a page that arrives
+// without it draws the price and the tokens and never the model.
+func TestHostedPlanPageCarriesTheLedgersModel(t *testing.T) {
+	workspace := t.TempDir()
+	t.Setenv("CODEAF_TASK_BELT", "bash")
+	store, err := session.OpenRunPlan(workspace, "Hosted run", "prove the model crosses the host")
+	if err != nil {
+		t.Fatalf("open run plan: %v", err)
+	}
+	if _, err := store.AddMany([]plandb.TaskSpec{{ID: "seeded", Title: "Seeded task", Description: "the real row"}}); err != nil {
+		t.Fatalf("seed run plan: %v", err)
+	}
+	if err := store.AddSpend("seeded", "z-ai/glm-5.3-flash", "worker", 0.0017, 20000, 1000); err != nil {
+		t.Fatalf("write spend: %v", err)
+	}
+	if err := store.Close(); err != nil {
+		t.Fatalf("close seeded plan: %v", err)
+	}
+
+	engine, err := session.New(session.Config{
+		Workspace: workspace,
+		Model:     "test/model",
+		APIKey:    "fixture",
+		BaseURL:   "http://127.0.0.1:1/v1",
+		System:    "Test only.",
+	})
+	if err != nil {
+		t.Fatalf("build real session agent: %v", err)
+	}
+	t.Cleanup(func() { _ = engine.Close() })
+
+	host := &Host{
+		workspace: workspace,
+		opts: Options{Boot: func(remote.Hello) (*remote.Engine, error) {
+			return &remote.Engine{Agent: engine, Workspace: workspace}, nil
+		}},
+		sessions: map[string]*remote.Session{},
+		done:     make(chan struct{}),
+	}
+	surface, hosted := net.Pipe()
+	go host.attach(hosted)
+	client, err := remote.Dial(surface, "", remote.Hello{Version: remote.Version, Workspace: workspace})
+	if err != nil {
+		t.Fatalf("dial hosted session: %v", err)
+	}
+	t.Cleanup(func() { _ = client.Close() })
+
+	page, ok := client.Agent().PlanTaskPage("t-seeded")
+	if !ok {
+		t.Fatal("PlanTaskPage over the host answered no page")
+	}
+	if page.Row.Model != "z-ai/glm-5.3-flash" {
+		t.Fatalf("page model = %q, want the ledger's z-ai/glm-5.3-flash (tokens %d usd %v)", page.Row.Model, page.Row.Tokens, page.Row.USD)
+	}
+	if page.Row.Tokens != 21000 {
+		t.Fatalf("page tokens = %d, want 21000", page.Row.Tokens)
+	}
+	work, found := client.Agent().PlanTaskWork("t-seeded")
+	if !found || work.NoDoor {
+		t.Fatalf("PlanTaskWork over the host = (%+v, %v), want the door to answer", work, found)
+	}
+}

internal/manual/chat/reading-a-task-page.md

@@ -181,6 +181,25 @@ all re-fit it. Only the overflow folds. The conversation keeps exactly the last
 calls in the no-caption fallback above a line reading `N earlier tool calls · ctrl+o`,
 and scrolling the conversation never opens a fold — `ctrl+o` or a click does.
 
+## See what a task changed: the `transcript` and `work` tabs, and the `tab` key
+
+Two tabs are named at the right of the top line, beside the way back: `transcript` and
+`work`. They are there for every task on either engine. `transcript` is everything this
+manual describes: the brief, the steps, the notes and the report. `work` shows the files
+changed.
+
+- On this window's own engine, `work` lists the files once the task has landed:
+  `files this task changed`, or `this task changed no files`. Before it lands it says
+  `the files this task changes are listed here when it lands`.
+- On a run's task, `work` is the run's working copy read against the commit it was cut
+  from: the difference, and the files added, with the files codeaf keeps there left out.
+  The whole run shares that one copy, and the tab says so at its top. Once the run has
+  ended its copy is given back, and the tab reads the work off the run's branch instead.
+  With that branch gone too, it says `the run's working copy is not here any more`.
+
+`tab` over an empty box moves from one tab to the other, and a click on a tab's name opens
+it. With words in the box, `tab` is the box's own key.
+
 ## What the line at the top of a task's page tells you
 
 **It is drawn under the conversation tabs, not above them.** Those say which conversation
@@ -399,12 +418,11 @@ the page says it in one dim line, above whatever else it already knows:
 - a read that came back with an error says `couldn't read this task's conversation ·
   retrying`, which is a different fact from either of the two above and keeps its beat
 
-**A run's task page follows its newest step the same way.** The page `enter` opens on a run's
-row — a row drawn in the tasks place — keeps up with the work: the newest step walks in at the
-bottom, and the page stays stuck to that live edge until you scroll up, which releases it.
-Scrolling back to the bottom resumes the follow, and a page on a task that has settled is a
-still page, never re-read. The step being run right now is drawn one step early, the running
-glyph beside its command.
+**A run's task follows its newest step the same way.** A task on the run engine opens this
+same room, read from the run's store, and keeps up with the work: the newest step walks in at
+the bottom, and the room stays stuck to that live edge until you scroll up, which releases it.
+Scrolling back to the bottom resumes the follow, and a room on a task that has settled is a
+still page, never re-read. The step being run right now is the newest call, drawn running.
 
 ## Why is a task I just started showing an empty page
 
@@ -578,11 +596,13 @@ until you answer it. A task that is still running is never refused: if nobody is
 to read you — it is being checked, or its worker has just closed — the line is held on the
 task's record instead, which the clause above says out loud.
 
-**A run task's page carries this box too**, and it says when the note is read rather than merely
-saved. Under the box the run page writes `the worker reads a note at its next step`: the note
-goes to the task's store and waits until the worker asks for its next step, which is when it
-reads what you wrote. A task that has ended, `done` or `incomplete`, takes no next step, so
-its page leaves that sentence out.
+**A run task's room carries this box too**, and it says when the note is read rather than merely
+saved. Once the store has the note the room writes `the worker reads a note at its next step`
+under it: the note waits in the store until the next step, which is when it is read. Once the
+work has ended, `done` or `incomplete`, there is no next step, so the room leaves that sentence
+out and takes no note: `enter` says `this task has finished` and where to say them instead, and
+leaves them in the box. A note the store refuses for another reason shows the store's own
+sentence on the line you typed.
 
 ## Task page says finished but the work is still running
 
@@ -740,7 +760,7 @@ tree's own connectors (`├─`, `└─`). A part that is running says the comm
 on, such as `bash go test ./...`, and under that how long it has run and what it
 has cost, each left out when the store has not got it.
 
-Select any row there and press `enter` to open that task's page. Press `esc` to
-return to the page you came from; the trail at the top of the page reads
-`<conversation> ▸ <parent title> ▸ <this task>` so you can see where it returns.
-This opens a page rather than changing the rail's fold.
+Click any row there to open that task's room. The trail at the top of the room reads
+`<conversation> ▸ <parent title> ▸ <this task>`, and a click on the parent's name in it
+opens the parent's room again. `esc` returns to the conversation. This opens a room
+rather than changing the rail's fold.