Merge app/v3 into workstreams/main

Brings the integration branch up to app/v3 (6 commits: the stored
repository list served with a background refresh, step conditions read
the change's files, step and My pipeline AI count as Factory AI, notes and
the completion guard share one command outcome, opening a job doesn't
count as a person's touch, a budget raise isn't refused by spend
progress). No conflicts; the three files both sides touched
(cmd/codeaf/app.go, internal/appwire/server.go,
docs/design/app-v3/PROTOCOL.md) merged line-disjoint.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: AbirAbbas

cmd/codeaf/app.go

@@ -2662,6 +2662,9 @@ func (b *appBackend) startTurnLocked(a *appAgent, text, clientID string, shown *
 		b.pump(a, id, live, turn, n, text, shown, events)
 		b.sendQueued(a, live)
 	})
+	if err := b.touchJobConversation(a.transcript); err != nil {
+		return turn, &appUnsureSend{err: appEngineError(err)}
+	}
 	return turn, nil
 }
 

cmd/codeaf/appagentid_cells_test.go

@@ -90,6 +90,7 @@ func TestAJobsChatsNameTheCellTalksFolder(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	makeJobManager(t, s, it.ID)
 	var chats appwire.FactoryJobChats
 	s.must("factory.job_chats", map[string]any{"factory": st.Factory, "job": it.ID}, &chats)
 	kept, err := s.backend.local.host.floor.Get(it.ID)

cmd/codeaf/appfactory.go

@@ -1065,9 +1065,10 @@ func (b *appBackend) FactoryJob(ctx context.Context, id string, job int) (api.Jo
 
 func (b *appBackend) FactoryRepos(ctx context.Context, id string) (appwire.FactoryRepos, error) {
 	var body struct {
-		Factory   api.Factory `json:"factory"`
-		Watched   []string    `json:"watched"`
-		Available []struct {
+		AvailableReadAt time.Time   `json:"available_read_at"`
+		Factory         api.Factory `json:"factory"`
+		Watched         []string    `json:"watched"`
+		Available       []struct {
 			Full    string    `json:"full"`
 			Name    string    `json:"name"`
 			Owner   string    `json:"owner"`
@@ -1081,7 +1082,7 @@ func (b *appBackend) FactoryRepos(ctx context.Context, id string) (appwire.Facto
 	if err := b.factoryHub().read(ctx, id, "/v1/repos", appFactoryBody, &body); err != nil {
 		return appwire.FactoryRepos{}, err
 	}
-	out := appwire.FactoryRepos{Factory: body.Factory, Watched: body.Watched, Available: make([]appwire.FactoryRepo, len(body.Available))}
+	out := appwire.FactoryRepos{AvailableReadAt: body.AvailableReadAt, Factory: body.Factory, Watched: body.Watched, Available: make([]appwire.FactoryRepo, len(body.Available))}
 	if out.Watched == nil {
 		out.Watched = []string{}
 	}

cmd/codeaf/appfactory_brief_spend_test.go

@@ -84,6 +84,7 @@ func TestAppFactoryBriefChargesEachProviderCallOnce(t *testing.T) {
 			var held api.WorkerPull
 			var baseline factory.Item
 			if outcome == "remote worker" {
+				makeJobManager(t, s, it.ID)
 				var chats appwire.FactoryJobChats
 				s.must("factory.job_chats", map[string]any{"factory": st.Factory, "job": it.ID}, &chats)
 				// local_start also runs this app's worker. Only the simulated

cmd/codeaf/appfactory_brief_writer.go

@@ -96,6 +96,14 @@ func (b *appBackend) writeBrief(ctx context.Context, factoryID string, job int,
 // briefErrand asks the job's agent for the brief. Every way of not
 // answering is a Reason, which the factory keeps as the write's failure.
 func (b *appBackend) briefErrand(ctx context.Context, factoryID string, job int, begin api.BriefBegin) session.ErrandAnswer {
+	host, err := b.localHostOf(factoryID)
+	if err != nil || host.seam.Talk == nil {
+		return session.ErrandAnswer{Reason: appwire.ErrandNotOpen}
+	}
+	// Writing a brief needs a manager; reading its chats no longer creates one.
+	if _, err := host.seam.Talk(ctx, job); err != nil {
+		return session.ErrandAnswer{Reason: appwire.ErrandNotOpen}
+	}
 	chats, err := b.FactoryJobChats(ctx, appwire.FactoryJobChatsParams{Factory: factoryID, Job: job})
 	if err != nil {
 		return session.ErrandAnswer{Reason: appwire.ErrandNotOpen}

cmd/codeaf/appfactory_budget_progress_test.go

@@ -0,0 +1,84 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/Agent-Field/codeaf/internal/appwire"
+	"github.com/Agent-Field/codeaf/internal/factory"
+	"github.com/Agent-Field/codeaf/internal/factory/api"
+	"github.com/Agent-Field/codeaf/internal/factory/lease"
+)
+
+func TestAppFactoryBudgetProgress(t *testing.T) {
+	for _, scenario := range []string{"spend-report", "other-editor", "budget-changed-back", "finished", "dropped"} {
+		t.Run(scenario, func(t *testing.T) {
+			s := newLocalSetup(t)
+			status := s.start()
+			floor := s.backend.local.host.floor
+			job, err := floor.Create(factory.Item{Repo: "acme/api", Kind: factory.KindIssue, State: factory.StateQueued, Cap: 5,
+				Stream: &factory.Stream{Phases: []factory.Phase{{Name: "build", State: factory.PhaseRunning}}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			desk, err := lease.Open(floor, lease.Options{})
+			if err != nil {
+				t.Fatal(err)
+			}
+			held, err := desk.Pull(lease.Worker{ID: "budget-worker", Handle: "owner", Solo: true})
+			if err != nil || held.Job != job.ID {
+				t.Fatalf("pull: %+v %v", held, err)
+			}
+			var before api.Job
+			s.must("factory.job", map[string]any{"factory": status.Factory, "job": job.ID}, &before)
+			if err := desk.Apply(held.ID, held.Worker, false, func(it *factory.Item) error {
+				it.Stream.Spent = .25
+				return nil
+			}); err != nil {
+				t.Fatal(err)
+			}
+			var moved api.Job
+			s.must("factory.job", map[string]any{"factory": status.Factory, "job": job.ID}, &moved)
+			if moved.Version <= before.Version {
+				t.Fatal("worker report did not advance version")
+			}
+			params := map[string]any{"factory": status.Factory, "job": job.ID,
+				"budget": 10, "expect": map[string]any{"version": before.Version}}
+			switch scenario {
+			case "other-editor", "budget-changed-back":
+				var edited appwire.FactoryJobActed
+				s.must("factory.job_set_budget", map[string]any{"factory": status.Factory, "job": job.ID,
+					"budget": 20, "expect": map[string]any{"version": moved.Version}}, &edited)
+				want := 20.0
+				if scenario == "budget-changed-back" {
+					s.must("factory.job_set_budget", map[string]any{"factory": status.Factory, "job": job.ID,
+						"budget": 5, "expect": map[string]any{"version": edited.Current.Version}}, &edited)
+					want = 5
+				}
+				s.mustFail("factory.job_set_budget", params, appwire.CodeConflict)
+				var current api.Job
+				s.must("factory.job", map[string]any{"factory": status.Factory, "job": job.ID}, &current)
+				if current.Budget != want || current.Version != edited.Current.Version {
+					t.Fatalf("stale editor changed job: %+v", current)
+				}
+				return
+			case "finished", "dropped":
+				if err := floor.Update(job.ID, func(it *factory.Item) error {
+					it.State = factory.StateShipped
+					if scenario == "dropped" {
+						it.State = factory.StateDismissed
+					}
+					return nil
+				}); err != nil {
+					t.Fatal(err)
+				}
+				s.mustFail("factory.job_set_budget", params, appwire.CodeConflict)
+				return
+			}
+			var raised appwire.FactoryJobActed
+			s.must("factory.job_set_budget", params, &raised)
+			if raised.Current == nil || raised.Current.Budget != 10 || raised.Current.Cost != .25 {
+				t.Fatalf("raise lost budget or report: %+v", raised.Current)
+			}
+		})
+	}
+}

cmd/codeaf/appfactory_chats.go

@@ -24,50 +24,27 @@ import (
 var _ appwire.FactoryJobChatter = (*appBackend)(nil)
 
 // FactoryJobChats answers one job's conversations on this machine's factory,
-// making the job's agent when it has none yet. It starts no job and asks no
-// model.
+// returning only conversations already recorded on the job. It writes no job.
 func (b *appBackend) FactoryJobChats(ctx context.Context, p appwire.FactoryJobChatsParams) (appwire.FactoryJobChats, error) {
 	host, err := b.localHostOf(p.Factory)
 	if err != nil {
 		return appwire.FactoryJobChats{}, err
 	}
-	if host.seam.Talk == nil {
-		return appwire.FactoryJobChats{}, appwire.Errorf(appwire.CodeEngine, "this factory cannot make a job's conversation here")
-	}
-	item, err := host.floor.Get(p.Job)
-	if err != nil || !factory.IsIssueJob(item) {
+	it, err := host.floor.Get(p.Job)
+	if err != nil || !factory.IsIssueJob(it) {
 		return appwire.FactoryJobChats{}, appwire.Errorf(appwire.CodeNotFound, "issue job not found")
 	}
-	talk, err := host.seam.Talk(ctx, p.Job)
-	if err != nil {
-		return appwire.FactoryJobChats{}, appwire.Errorf(appwire.CodeNotFound, "the job's conversation could not be opened: %s", err.Error())
+	if err := factory.RefuseDropped(it); err != nil {
+		return appwire.FactoryJobChats{}, appwire.Errorf(appwire.CodeNotFound, "%s", err)
 	}
-	it, err := host.floor.Get(p.Job)
-	if err != nil {
-		return appwire.FactoryJobChats{}, appwire.Errorf(appwire.CodeNotFound, "there is no job %d in this factory", p.Job)
-	}
-	out := appwire.FactoryJobChats{Factory: p.Factory, Job: p.Job, Agent: appAgentID(talk), Steps: []appwire.FactoryJobStepChat{}}
-	// Whenever the job's agent is opened, by this read or later by a send or
-	// Reopen, it takes the job's effort as the job then has it.
-	if a, err := b.find(out.Agent); err == nil && a != nil {
-		floor, job := host.floor, p.Job
-		b.locked(func() {
-			a.jobEffort = func() string {
-				it, err := floor.Get(job)
-				if err != nil {
-					return ""
-				}
-				return it.Effort
-			}
-		})
-	}
-	held, err := b.holdJobChat(out.Agent)
-	if err != nil {
-		return appwire.FactoryJobChats{}, err
+	out := appwire.FactoryJobChats{Factory: p.Factory, Job: p.Job, Steps: []appwire.FactoryJobStepChat{}}
+	if talk := strings.TrimSpace(it.Talk); talk != "" {
+		out.Agent = appAgentID(talk)
 	}
-	// A held agent takes it now; a closed one keeps its own until it is opened.
-	if held && it.Effort != "" {
-		_, _ = b.SetEffort(out.Agent, it.Effort)
+	if out.Agent != "" {
+		if err := b.holdJobManager(host, p.Job, out.Agent); err != nil {
+			return appwire.FactoryJobChats{}, err
+		}
 	}
 	if it.Stream != nil {
 		for _, ph := range it.Stream.Phases {
@@ -87,6 +64,26 @@ func (b *appBackend) FactoryJobChats(ctx context.Context, p appwire.FactoryJobCh
 	return out, nil
 }
 
+// holdJobManager binds future opens to the job's current effort without saving it.
+func (b *appBackend) holdJobManager(host *appFactoryHost, job int, id string) error {
+	a, err := b.find(id)
+	if err != nil {
+		return err
+	}
+	floor := host.floor
+	b.locked(func() {
+		a.jobEffort = func() string {
+			it, err := floor.Get(job)
+			if err != nil {
+				return ""
+			}
+			return it.Effort
+		}
+	})
+	_, err = b.holdJobChat(id)
+	return err
+}
+
 // roundChats is each finished round's chat that can be opened, held open as
 // the step's own is. The same rule leaves a round out as a step: one whose chat
 // cannot be opened is never answered.

cmd/codeaf/appfactory_chats_closed_test.go

@@ -35,6 +35,7 @@ func TestViewingAJobsPageLeavesItsClosedChatsClosed(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	makeJobManager(t, s, it.ID)
 	read := func() appwire.FactoryJobChats {
 		var chats appwire.FactoryJobChats
 		s.must("factory.job_chats", map[string]any{"factory": st.Factory, "job": it.ID}, &chats)
@@ -114,6 +115,7 @@ func TestAJobsClosedChatTakesTheJobsEffortWhenItIsOpenedAgain(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	makeJobManager(t, s, it.ID)
 	read := func() appwire.FactoryJobChats {
 		var chats appwire.FactoryJobChats
 		s.must("factory.job_chats", map[string]any{"factory": st.Factory, "job": it.ID}, &chats)

cmd/codeaf/appfactory_chats_test.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"strings"
 	"testing"
 	"time"
@@ -10,11 +11,10 @@ import (
 	"github.com/Agent-Field/codeaf/internal/session"
 )
 
-// A JOB'S CONVERSATIONS ARE ITS OWN PAGE'S. Reading them makes the job's agent
-// once (the same one on every read after), keeps it on the job, holds it open
+// A job's page returns its existing manager on every read and holds it open
 // for the app, lists no step that has not run, and starts nothing; another
 // factory's chats are not this engine's to answer.
-func TestAJobsChatsAreItsAgentMadeOnceAndItsStepsThatRan(t *testing.T) {
+func TestAJobsChatsAreItsExistingAgentAndItsStepsThatRan(t *testing.T) {
 	s := newLocalSetup(t)
 	// The app opens a conversation through its opener; this one holds a fake.
 	s.backend.open = func(ask appOpenAsk) (*appConn, error) {
@@ -26,6 +26,7 @@ func TestAJobsChatsAreItsAgentMadeOnceAndItsStepsThatRan(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	makeJobManager(t, s, it.ID)
 	var first appwire.FactoryJobChats
 	s.must("factory.job_chats", map[string]any{"factory": st.Factory, "job": it.ID}, &first)
 	if first.Agent == "" || len(first.Steps) != 0 {
@@ -176,6 +177,7 @@ func TestFactoryChatRefreshKeepsThePersonsModelPair(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	makeJobManager(t, s, it.ID)
 	var chats appwire.FactoryJobChats
 	read := func() { s.must("factory.job_chats", map[string]any{"factory": st.Factory, "job": it.ID}, &chats) }
 	read()
@@ -197,3 +199,11 @@ func TestFactoryChatRefreshKeepsThePersonsModelPair(t *testing.T) {
 		}
 	}
 }
+
+// makeJobManager explicitly creates the existing manager a read fixture needs.
+func makeJobManager(t *testing.T, s *localSetup, job int) {
+	t.Helper()
+	if _, err := s.backend.local.host.seam.Talk(context.Background(), job); err != nil {
+		t.Fatal(err)
+	}
+}

cmd/codeaf/appfactory_job_pause_test.go

@@ -94,6 +94,7 @@ func TestFactoryRunningJobPause(t *testing.T) {
 		s.backend.open = func(ask appOpenAsk) (*appConn, error) {
 			return &appConn{Conv: &fakeConversation{}, Workspace: ask.Workspace, Transcript: ask.Transcript, Release: func() {}}, nil
 		}
+		makeJobManager(t, s, it.ID)
 		var chats appwire.FactoryJobChats
 		s.must("factory.job_chats", params, &chats)
 		desk, err := lease.Open(floor, lease.Options{})
@@ -639,6 +640,7 @@ func TestFactoryResumeChat(t *testing.T) {
 				}
 			}
 			params := map[string]any{"factory": status.Factory, "job": it.ID}
+			makeJobManager(t, s, it.ID)
 			var chats appwire.FactoryJobChats
 			s.must("factory.job_chats", params, &chats)
 			act := func(method string) {
@@ -689,6 +691,7 @@ func TestFactoryResumeChatRetries(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	makeJobManager(t, s, it.ID)
 	var chats appwire.FactoryJobChats
 	s.must("factory.job_chats", map[string]any{"factory": status.Factory, "job": it.ID}, &chats)
 	desk, err := lease.Open(floor, lease.Options{})