relay-flow 0.2.0-alpha → 0.2.1-alpha

package/internal/execution/goworkflows/engine.go

@@ -32,9 +32,10 @@ import (
 
 // Dependencies carries the replaceable boundaries used by activities.
 type Dependencies struct {
-	Repos   *repo.Registry
-	Runner  runner.Runner
-	Harness harness.Harness
+	Repos      *repo.Registry
+	Runner     runner.Runner
+	Harness    harness.Harness
+	TaskSystem string
 
 	// RetentionDays bounds completed/canceled run retention; zero uses the
 	// machine default of 30 days.
@@ -91,6 +92,23 @@ func InitDatabase(path string) error {
 	return nil
 }
 
+// HasNonterminalRuns inspects an existing database without migrating or
+// otherwise modifying it. It is used by init --force before config changes.
+func HasNonterminalRuns(path string) (bool, error) {
+	db, err := sql.Open("sqlite", fmt.Sprintf("file:%s?mode=ro", path))
+	if err != nil {
+		return false, fmt.Errorf("open %s: %w", path, err)
+	}
+	defer db.Close()
+	var active bool
+	if err := db.QueryRow(`SELECT EXISTS(
+		SELECT 1 FROM relay_runs WHERE state NOT IN ('completed', 'canceled')
+	)`).Scan(&active); err != nil {
+		return false, fmt.Errorf("inspect %s: %w", path, err)
+	}
+	return active, nil
+}
+
 // New opens the SQLite database at path (created with mode 0600 when
 // missing), migrates the relay_runs projection, and constructs the engine.
 // A corrupt database file fails here.
@@ -130,10 +148,11 @@ func New(path string, deps Dependencies) (*Engine, error) {
 		return nil, fmt.Errorf("migrate relay_runs: %w", err)
 	}
 	activities := &Activities{
-		Repos:   deps.Repos,
-		Runner:  deps.Runner,
-		Harness: deps.Harness,
-		Runs:    proj,
+		Repos:      deps.Repos,
+		Runner:     deps.Runner,
+		Harness:    deps.Harness,
+		TaskSystem: deps.TaskSystem,
+		Runs:       proj,
 	}
 	retention := 30 * 24 * time.Hour
 	if deps.RetentionDays > 0 {
@@ -204,6 +223,7 @@ func (e *Engine) registerActivities() error {
 		a.ValidateAgents,
 		a.ApplyTaskConfig,
 		a.EnsureEnvironment,
+		a.SetEnvironmentStatus,
 		a.LoadNodeRuntime,
 		a.EnsureNodeRuntime,
 		a.CloseTerminals,
@@ -291,6 +311,19 @@ func (e *Engine) EnsureRun(ctx context.Context, start run.Start) (bool, error) {
 	if err != nil {
 		return false, err
 	}
+	if r.State != run.StateCompleted && r.State != run.StateCanceled && r.State != run.StateCanceling {
+		if _, err := e.instance(ctx, start.ID); errors.Is(err, sql.ErrNoRows) {
+			start.Runtime = e.runtime
+			if _, err := e.client.CreateWorkflowInstance(ctx,
+				client.WorkflowInstanceOptions{InstanceID: string(start.ID)},
+				e.activities.TicketWorkflow, start); err != nil && !errors.Is(err, backend.ErrInstanceAlreadyExists) {
+				return false, fmt.Errorf("create missing workflow instance %s: %w", start.ID, err)
+			}
+			return true, nil
+		} else if err != nil {
+			return false, err
+		}
+	}
 	// Existing run: reconcile only an active run at a work node.
 	if r.State == run.StateCompleted || r.State == run.StateCanceled || r.State == run.StateCanceling {
 		return false, nil
@@ -304,7 +337,7 @@ func (e *Engine) EnsureRun(ctx context.Context, start run.Start) (bool, error) {
 	}
 	ok := false
 	if runtime.TerminalID != "" {
-		_, ok, _ = e.activities.Runner.InspectTerminal(ctx, runner.Terminal{
+		_, ok, _ = e.activities.Runner.FindTerminal(ctx, runner.Terminal{
 			ID: runtime.TerminalID, Title: r.Ticket.Key + ":" + r.CurrentNode,
 		})
 	}

package/internal/execution/goworkflows/engine_test.go

@@ -2,6 +2,7 @@ package goworkflows_test
 
 import (
 	"context"
+	"database/sql"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -39,23 +40,25 @@ func linearWorkflow(cleanup bool) workflow.Workflow {
 	}
 }
 
-func TestMailboxDescriptionRequiresQuestionForHITL(t *testing.T) {
+func TestMailboxDescriptionAndLaunchPromptAreTaskSystemNeutral(t *testing.T) {
 	wf := linearWorkflow(false)
 	node := wf.Nodes["coding"]
 	node.Type = workflow.NodeHITL
 	description := goworkflows.MailboxSpecForNode(&wf, "PAY-101", "coding", node).Description
 	for _, want := range []string{
+		"Parent ticket: PAY-101",
 		"Do not make code changes",
 		"until the human is satisfied with the review",
-		"OpenCode's Question tool",
-		"Approve and Reject",
-		"If approved, output the report verbatim",
-		"If rejected, return to step 1",
 	} {
 		if !strings.Contains(description, want) {
 			t.Fatalf("HITL mailbox description missing %q:\n%s", want, description)
 		}
 	}
+	for _, unwanted := range []string{"Jira", "OpenCode", "Question tool"} {
+		if strings.Contains(description, unwanted) {
+			t.Fatalf("generic mailbox description contains %q:\n%s", unwanted, description)
+		}
+	}
 
 	node.Type = workflow.NodeAgent
 	agentDescription := goworkflows.MailboxSpecForNode(&wf, "PAY-101", "coding", node).Description
@@ -63,14 +66,18 @@ func TestMailboxDescriptionRequiresQuestionForHITL(t *testing.T) {
 		t.Fatalf("agent mailbox description contains HITL Question instruction:\n%s", agentDescription)
 	}
 
-	prompt := goworkflows.BuildLaunchSpecPrompt("PAY-101", "PAY-234")
-	for _, want := range []string{"parent Jira ticket PAY-101", "mailbox subtask is PAY-234", "description and comments"} {
-		if !strings.Contains(prompt, want) {
-			t.Fatalf("compact launch prompt missing %q: %q", want, prompt)
+	for _, taskSystem := range []string{"jira", "linear"} {
+		prompt := goworkflows.BuildLaunchSpecPrompt(taskSystem, "PAY-101", "PAY-234")
+		want := "Task system: " + taskSystem + "\nUse the " + taskSystem + " tools to read the parent ticket PAY-101.\n\nYour mailbox is PAY-234. Read its description and comments for node instructions and feedback."
+		if prompt != want {
+			t.Fatalf("BuildLaunchSpecPrompt(%s) = %q, want %q", taskSystem, prompt, want)
+		}
+		if strings.Contains(prompt, "Jira") || strings.Contains(prompt, "subtask") {
+			t.Fatalf("launch prompt contains task-system-specific mailbox wording: %q", prompt)
+		}
+		if strings.Contains(prompt, "STATUS:") || strings.Contains(prompt, node.Description) {
+			t.Fatalf("launch prompt duplicates mailbox instructions: %q", prompt)
 		}
-	}
-	if strings.Contains(prompt, "STATUS:") || strings.Contains(prompt, node.Description) {
-		t.Fatalf("launch prompt duplicates mailbox instructions: %q", prompt)
 	}
 }
 
@@ -104,6 +111,50 @@ func newEngine(t *testing.T, deps goworkflows.Dependencies) *goworkflows.Engine
 	return e
 }
 
+func TestEnsureRunCreatesMissingWorkflowForExistingProjection(t *testing.T) {
+	log := newEventLog()
+	sys := newFakeTaskSystem(log)
+	path := filepath.Join(t.TempDir(), "state.db")
+	deps := goworkflows.Dependencies{
+		Repos: repoRegistryWith("payments", sys), Runner: newFakeRunner(log), Harness: newFakeHarness(log),
+	}
+	engine, err := goworkflows.New(path, deps)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wf := linearWorkflow(false)
+	rid := identity.NewRunID("payments", wf.Name, "PAY-101")
+	db, err := sql.Open("sqlite", path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := db.Exec(`INSERT INTO relay_runs
+		(id, repo, workflow, ticket_id, ticket_key, state, started_at, updated_at)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, rid, "payments", wf.Name, "1", "PAY-101", run.StateStarting, time.Now(), time.Now()); err != nil {
+		t.Fatal(err)
+	}
+	db.Close()
+	if err := engine.Start(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = engine.Shutdown(context.Background()) })
+
+	created, err := engine.EnsureRun(context.Background(), run.Start{
+		ID: rid, Repo: "payments", RepoPath: "/srv/payments", Workflow: wf,
+		Ticket: task.TicketRef{ID: "1", Key: "PAY-101"},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !created {
+		t.Fatal("EnsureRun did not create the missing workflow instance")
+	}
+	waitFor(t, 10*time.Second, func() bool {
+		r, err := engine.GetRun(context.Background(), rid)
+		return err == nil && r.CurrentNode == "coding"
+	})
+}
+
 func successReport(next string) workflow.Report {
 	none := "None"
 	return workflow.Report{
@@ -233,6 +284,9 @@ func TestRevisitCreatesNewVisit(t *testing.T) {
 		r, _ := engine.GetRun(context.Background(), rid)
 		return r.CurrentNode == "coding" && r.CurrentNodeVisitID != ""
 	})
+	if indexOf(log.all(), "environmentStatus:in-progress") < 0 {
+		t.Fatalf("agent node did not set workspace status in-progress; events=%v", log.all())
+	}
 
 	r, _ := engine.GetRun(context.Background(), rid)
 	first := r.CurrentNodeVisitID
@@ -329,6 +383,9 @@ func TestEndCleanupDisabledKeepsRetainedRunner(t *testing.T) {
 		r, _ := engine.GetRun(context.Background(), rid)
 		return r.State == run.StateCompleted
 	})
+	if indexOf(log.all(), "environmentStatus:completed") < 0 {
+		t.Fatalf("end did not set workspace status completed; events=%v", log.all())
+	}
 	if len(fr.cleaned) != 0 || fr.liveTerminals() != 1 {
 		t.Fatalf("cleanup disabled: CleanupRun calls=%v live terminals=%d, want 0 and 1", fr.cleaned, fr.liveTerminals())
 	}
@@ -378,6 +435,10 @@ func TestTransitionOrdering(t *testing.T) {
 		r, _ := engine.GetRun(context.Background(), rid)
 		return r.CurrentNode == "review"
 	})
+	events := log.all()
+	if statusIdx, terminalIdx := indexOf(events, "environmentStatus:in-review"), indexOf(events, "ensureTerminal:PAY-101:review"); statusIdx < 0 || terminalIdx < 0 || statusIdx >= terminalIdx {
+		t.Fatalf("HITL status was not set before terminal start; events=%v", events)
+	}
 
 	// Exact cross-primitive order, observed through the fake-adapter and fake-
 	// runner call logs (the settled observation seam):
@@ -388,7 +449,6 @@ func TestTransitionOrdering(t *testing.T) {
 	// (recovery_test.go): a crash after acceptance, with comment injection
 	// failing, restarts on the same db and resumes the PERSISTED selected route
 	// without re-asking the agent or re-running effects.
-	events := log.all()
 	idx := map[string]int{}
 	for _, want := range []string{
 		"comment:PAY-101-coding",         // summary to current mailbox

package/internal/execution/goworkflows/fakes_test.go

@@ -337,21 +337,17 @@ func (f *fakeRunner) EnsureEnvironment(_ context.Context, spec runner.RunSpec) (
 	return e, nil
 }
 
-func (f *fakeRunner) FindTerminal(_ context.Context, env runner.Environment, title string) (runner.Terminal, bool, error) {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	f.log.add("findTerminal:" + title)
-	ft, ok := f.terminals[env.ID+"/"+title]
-	if !ok || !ft.live {
-		return runner.Terminal{}, false, nil
-	}
-	return ft.term, true, nil
+func (f *fakeRunner) SetEnvironmentStatus(_ context.Context, _ runner.Environment, status string) error {
+	f.log.add("environmentStatus:" + status)
+	return nil
 }
 
-func (f *fakeRunner) InspectTerminal(_ context.Context, terminal runner.Terminal) (runner.Terminal, bool, error) {
+func (f *fakeRunner) FindTerminal(_ context.Context, terminal runner.Terminal) (runner.Terminal, bool, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
-	f.log.add("inspectTerminal:" + terminal.ID)
+	if terminal.ID != "" {
+		f.log.add("findTerminalID:" + terminal.ID)
+	}
 	for _, ft := range f.terminals {
 		if ft.term.ID == terminal.ID && ft.live {
 			return ft.term, true, nil
@@ -381,17 +377,13 @@ func (f *fakeRunner) CreateTerminal(ctx context.Context, env runner.Environment,
 	return t, nil
 }
 
-func (f *fakeRunner) EnsureTerminal(_ context.Context, env runner.Environment, title string, _ runner.Command) (runner.Terminal, error) {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	key := env.ID + "/" + title
-	if ft, ok := f.terminals[key]; ok && ft.live {
-		return ft.term, nil
+func (f *fakeRunner) EnsureTerminal(ctx context.Context, env runner.Environment, stored runner.Terminal, title string, command runner.Command) (runner.Terminal, error) {
+	if terminal, ok, err := f.FindTerminal(ctx, stored); err != nil {
+		return runner.Terminal{}, err
+	} else if ok {
+		return terminal, nil
 	}
-	t := runner.Terminal{ID: "t-" + key, Title: title}
-	f.terminals[key] = &fakeTerminal{term: t, live: true, title: title}
-	f.log.add("ensureTerminal:" + title)
-	return t, nil
+	return f.CreateTerminal(ctx, env, title, command)
 }
 
 func (f *fakeRunner) CloseTerminal(_ context.Context, t runner.Terminal) error {

package/internal/execution/goworkflows/interpreter.go

@@ -194,11 +194,12 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 		// are also retained separately for live-terminal revisits.
 		nextSteps := append(append([]workflow.Route{}, node.OnSuccess...), node.OnFailure...)
 		nudge, err := wf.RenderNudge(current, workflow.NudgeTemplateData{
-			Ticket:    start.Ticket.Key,
-			Workflow:  wf.Name,
-			Repo:      start.Repo,
-			Node:      current,
-			NextSteps: nextStepsText(nextSteps),
+			TaskSystem: a.TaskSystem,
+			Ticket:     start.Ticket.Key,
+			Workflow:   wf.Name,
+			Repo:       start.Repo,
+			Node:       current,
+			NextSteps:  nextStepsText(nextSteps),
 		})
 		if err != nil {
 			return err
@@ -214,7 +215,7 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 			NodeType:    node.Type,
 			Agent:       node.Agent,
 			Title:       title,
-			Prompt:      BuildLaunchSpecPrompt(start.Ticket.Key, mb.Key),
+			Prompt:      BuildLaunchSpecPrompt(a.TaskSystem, start.Ticket.Key, mb.Key),
 			NudgePrompt: nudge,
 			NextSteps:   nextSteps,
 		}
@@ -360,6 +361,13 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 		}); err != nil {
 		return err
 	}
+	if _, err := retryLoop(ctx, start.ID, a, work, "end",
+		func(ctx2 goworkflow.Context) goworkflow.Future[struct{}] {
+			return goworkflow.ExecuteActivity[struct{}](ctx2, noNativeRetries,
+				a.SetEnvironmentStatus, work, start.RepoPath, runner.WorkspaceStatusCompleted)
+		}); err != nil {
+		return err
+	}
 	finalPolicy := work.Runtime
 	if wf.CleanupRunnerOnEnd {
 		finalPolicy.KeepTerminalsAlive = false
@@ -401,7 +409,7 @@ func (a *Activities) runGraph(ctx goworkflow.Context, start run.Start) error {
 // run-level activities like EnsureMailboxes / start/end ApplyTaskConfig).
 // The log is wrapped in a replay-safe SideEffect so replays never re-emit
 // it, and the error message is sanitized so info logs never embed argv
-// payloads (acli/orca --body/--command/JQL/prompt strings).
+// payloads (Jira/Orca request bodies, commands, JQL, and prompt strings).
 func retryLoop[T any](ctx goworkflow.Context, id run.ID, a *Activities, work run.Work, node string, schedule func(goworkflow.Context) goworkflow.Future[T]) (T, error) {
 	var zero T
 	attempt := 0
@@ -475,7 +483,7 @@ func logRetry(ctx goworkflow.Context, work run.Work, node string, f retry.Failur
 }
 
 // sanitizeRetryMessage strips each "[...]: " argv-listing span that adapter
-// wrappers embed (acli [args...]:, orca [args...]:) so the info-level retry
+// wrappers may embed argv/request context, so the info-level retry
 // record never leaks --body/--command/JQL/prompt payloads. Keeps the
 // surrounding wrap context and trailing exit status / stderr fragment that
 // carry the failure reason. The original error returned to callers is

package/internal/execution/goworkflows/node_runtime_integration_test.go

@@ -84,8 +84,8 @@ func TestPersistedRuntimeLoopAndRestart(t *testing.T) {
 	if err != nil || !staleAck.Duplicate {
 		t.Fatalf("stale ack=%+v err=%v", staleAck, err)
 	}
-	if log.count("findTerminal:") != 0 {
-		t.Fatalf("normal path used title discovery: %v", log.all())
+	if log.count("findTerminalID:") == 0 {
+		t.Fatalf("normal path did not check persisted terminal IDs: %v", log.all())
 	}
 	if log.count("findSession:") != 0 {
 		t.Fatalf("normal path used session discovery: %v", log.all())
@@ -93,7 +93,7 @@ func TestPersistedRuntimeLoopAndRestart(t *testing.T) {
 
 	oldTerminal := secondRT.TerminalID
 	fr.killTerminals()
-	findTerminalBefore := log.count("findTerminal:")
+	findTerminalBefore := log.count("findTerminalID:")
 	findSessionBefore := log.count("findSession:")
 	e2 := restartEngine(t, db, deps, e1)
 	waitFor(t, 10*time.Second, func() bool {
@@ -104,13 +104,19 @@ func TestPersistedRuntimeLoopAndRestart(t *testing.T) {
 		t.Fatal(err)
 	}
 	resumeEvent := "buildCommand:implement:" + string(second.CurrentNodeVisitID) + ":resume=session-implement"
-	waitFor(t, 10*time.Second, func() bool { return log.count(resumeEvent) == 1 })
+	waitFor(t, 10*time.Second, func() bool {
+		runtime, _ := e2.GetNodeRuntime(context.Background(), rid, "implement")
+		return runtime.TerminalID != "" && runtime.TerminalID != oldTerminal
+	})
 	after, _ := e2.GetNodeRuntime(context.Background(), rid, "implement")
 	if after.TerminalID == oldTerminal || after.SessionID != "session-implement" || after.NodeVisitID != second.CurrentNodeVisitID {
 		t.Fatalf("restart did not resume/replace direct runtime: old=%+v after=%+v", secondRT, after)
 	}
-	if log.count("findTerminal:") != findTerminalBefore || log.count("findSession:") != findSessionBefore {
-		t.Fatalf("restart used discovery: %v", log.all())
+	if log.count("findTerminalID:") == findTerminalBefore || log.count("findSession:") != findSessionBefore {
+		t.Fatalf("restart did not use only the persisted terminal/session IDs: %v", log.all())
+	}
+	if log.count(resumeEvent) < 1 {
+		t.Fatalf("restart did not pass persisted session ID to harness: %v", log.all())
 	}
 }
 

package/internal/execution/goworkflows/node_runtime_test.go

@@ -189,7 +189,7 @@ func TestNodeRuntimeSessionRegistrationKeepsOldSessionBoundToOldVisit(t *testing
 
 func TestEnsureNodeRuntimeUsesDirectIDsAndFallsBackFresh(t *testing.T) {
 	ctx := context.Background()
-	fr := &runtimeTestRunner{createErr: runner.ErrSessionUnavailable}
+	fr := &runtimeTestRunner{}
 	fh := &runtimeTestHarness{}
 	db := openProjectionDB(t, filepath.Join(t.TempDir(), "state.db"))
 	defer db.Close()
@@ -219,11 +219,17 @@ func TestEnsureNodeRuntimeUsesDirectIDsAndFallsBackFresh(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if rt.TerminalID == "" || rt.TerminalID == "dead-term" || rt.SessionID != "" {
+	if rt.TerminalID == "" || rt.TerminalID == "dead-term" || rt.SessionID != "dead-session" {
 		t.Fatalf("failed direct IDs not replaced atomically: %+v", rt)
 	}
-	if fr.findCalls != 0 || fh.buildCalls != 2 || fr.createCalls != 2 {
-		t.Fatalf("fallback used discovery or wrong launch count: find=%d build=%d create=%d", fr.findCalls, fh.buildCalls, fr.createCalls)
+	if fr.findCalls != 1 || fh.buildCalls != 1 || fr.createCalls != 1 {
+		t.Fatalf("stored-ID replacement calls: find=%d build=%d create=%d", fr.findCalls, fh.buildCalls, fr.createCalls)
+	}
+	if len(fr.findIDs) != 1 || fr.findIDs[0] != "dead-term" {
+		t.Fatalf("FindTerminal IDs = %v, want [dead-term]", fr.findIDs)
+	}
+	if len(fh.resumeIDs) != 1 || fh.resumeIDs[0] != "dead-session" {
+		t.Fatalf("BuildCommand ResumeIDs = %v, want [dead-session]", fh.resumeIDs)
 	}
 	for _, prompt := range fh.prompts {
 		if prompt != "work" {
@@ -248,15 +254,19 @@ func TestEnsureNodeRuntimeInitialLaunchAppendsCustomInstructions(t *testing.T) {
 		t.Fatal(err)
 	}
 	fh := &runtimeTestHarness{}
-	a := &Activities{Runner: &runtimeTestRunner{}, Harness: fh, Runs: p}
+	fr := &runtimeTestRunner{}
+	a := &Activities{Runner: fr, Harness: fh, Runs: p}
 	nw := run.NodeWork{Work: run.Work{RunID: id}, Node: "implement", NodeVisitID: "visit-first"}
-	spec := harness.LaunchSpec{RunID: id, NodeVisitID: "visit-first", Node: "implement", Agent: "build", Prompt: "standard prompt", NudgePrompt: "custom instructions"}
+	spec := harness.LaunchSpec{RunID: id, NodeVisitID: "visit-first", Node: "implement", NodeType: workflow.NodeHITL, Agent: "build", Prompt: "standard prompt", NudgePrompt: "custom instructions"}
 	if err := a.EnsureNodeRuntime(ctx, nw, "", spec, NodeRuntime{}); err != nil {
 		t.Fatal(err)
 	}
 	if len(fh.prompts) != 1 || fh.prompts[0] != "standard prompt\n\ncustom instructions" {
 		t.Fatalf("initial prompt = %q", fh.prompts)
 	}
+	if len(fr.statuses) != 1 || fr.statuses[0] != runner.WorkspaceStatusInReview {
+		t.Fatalf("HITL workspace statuses = %v, want in-review", fr.statuses)
+	}
 }
 
 func TestEnsureNodeRuntimeSendFailureClosesLiveTerminal(t *testing.T) {
@@ -295,9 +305,12 @@ func TestEnsureNodeRuntimeSendFailureClosesLiveTerminal(t *testing.T) {
 		t.Fatalf("revisit replacement prompt = %q", fh.prompts)
 	}
 	rt, _ := p.getNodeRuntime(ctx, id, "implement")
-	if rt.TerminalID == "live-old" || rt.SessionID != "" {
+	if rt.TerminalID == "live-old" || rt.SessionID != "session-old" {
 		t.Fatalf("send failure did not replace IDs: %+v", rt)
 	}
+	if len(fh.resumeIDs) != 1 || fh.resumeIDs[0] != "session-old" {
+		t.Fatalf("replacement ResumeIDs = %v, want [session-old]", fh.resumeIDs)
+	}
 }
 
 func TestEnsureNodeRuntimeSameVisitSendsNothing(t *testing.T) {
@@ -412,14 +425,16 @@ func TestEngineRuntimePolicyDefaultsKeepBoth(t *testing.T) {
 }
 
 type runtimeTestRunner struct {
-	createErr   error
 	findCalls   int
+	findIDs     []string
 	createCalls int
 	live        bool
+	liveID      string
 	sendErr     error
 	sentTexts   []string
 	closeCalls  int
 	closedIDs   []string
+	statuses    []string
 }
 
 func (*runtimeTestRunner) DiscoverRepos(context.Context) ([]runner.RepoCandidate, error) {
@@ -429,8 +444,17 @@ func (*runtimeTestRunner) ValidateRepo(context.Context, string, string) error {
 func (*runtimeTestRunner) EnsureEnvironment(context.Context, runner.RunSpec) (runner.Environment, error) {
 	return runner.Environment{ID: "env"}, nil
 }
-func (r *runtimeTestRunner) InspectTerminal(_ context.Context, terminal runner.Terminal) (runner.Terminal, bool, error) {
-	return terminal, r.live, nil
+func (r *runtimeTestRunner) SetEnvironmentStatus(_ context.Context, _ runner.Environment, status string) error {
+	r.statuses = append(r.statuses, status)
+	return nil
+}
+func (r *runtimeTestRunner) FindTerminal(_ context.Context, terminal runner.Terminal) (runner.Terminal, bool, error) {
+	r.findCalls++
+	r.findIDs = append(r.findIDs, terminal.ID)
+	if !r.live || (r.liveID != "" && terminal.ID != r.liveID) {
+		return runner.Terminal{}, false, nil
+	}
+	return terminal, true, nil
 }
 func (r *runtimeTestRunner) SendTerminal(_ context.Context, _ runner.Terminal, text string) error {
 	r.sentTexts = append(r.sentTexts, text)
@@ -438,16 +462,9 @@ func (r *runtimeTestRunner) SendTerminal(_ context.Context, _ runner.Terminal, t
 }
 func (r *runtimeTestRunner) CreateTerminal(context.Context, runner.Environment, string, runner.Command) (runner.Terminal, error) {
 	r.createCalls++
-	if r.createErr != nil {
-		err := r.createErr
-		r.createErr = nil
-		return runner.Terminal{}, err
-	}
-	return runner.Terminal{ID: "fresh-term"}, nil
-}
-func (r *runtimeTestRunner) FindTerminal(context.Context, runner.Environment, string) (runner.Terminal, bool, error) {
-	r.findCalls++
-	return runner.Terminal{}, false, nil
+	r.live = true
+	r.liveID = "fresh-term"
+	return runner.Terminal{ID: r.liveID}, nil
 }
 func (r *runtimeTestRunner) CloseTerminal(_ context.Context, terminal runner.Terminal) error {
 	r.closeCalls++
@@ -455,7 +472,12 @@ func (r *runtimeTestRunner) CloseTerminal(_ context.Context, terminal runner.Ter
 	r.live = false
 	return nil
 }
-func (r *runtimeTestRunner) EnsureTerminal(ctx context.Context, env runner.Environment, title string, command runner.Command) (runner.Terminal, error) {
+func (r *runtimeTestRunner) EnsureTerminal(ctx context.Context, env runner.Environment, stored runner.Terminal, title string, command runner.Command) (runner.Terminal, error) {
+	if terminal, ok, err := r.FindTerminal(ctx, stored); err != nil {
+		return runner.Terminal{}, err
+	} else if ok {
+		return terminal, nil
+	}
 	return r.CreateTerminal(ctx, env, title, command)
 }
 func (*runtimeTestRunner) CloseTerminals(context.Context, runner.RunSpec) error { return nil }
@@ -464,6 +486,7 @@ func (*runtimeTestRunner) CleanupRun(context.Context, runner.RunSpec) error
 type runtimeTestHarness struct {
 	buildCalls int
 	prompts    []string
+	resumeIDs  []string
 }
 
 func (*runtimeTestHarness) ValidateAgent(context.Context, string, string) error { return nil }
@@ -473,6 +496,7 @@ func (*runtimeTestHarness) FindSession(context.Context, string, string) (harness
 func (h *runtimeTestHarness) BuildCommand(spec harness.LaunchSpec) (runner.Command, error) {
 	h.buildCalls++
 	h.prompts = append(h.prompts, spec.Prompt)
+	h.resumeIDs = append(h.resumeIDs, spec.ResumeID)
 	return runner.Command{Executable: "opencode", Args: []string{spec.ResumeID}}, nil
 }
 

package/internal/execution/goworkflows/recovery_test.go

@@ -490,7 +490,7 @@ func TestTerminalReconcile(t *testing.T) {
 	terminalsBefore := fr.liveTerminals()
 	relaunchBefore := log.count("ensureTerminal:PAY-101:coding")
 	buildBefore := log.count("buildCommand:")
-	inspectBefore := log.count("inspectTerminal:")
+	inspectBefore := log.count("findTerminalID:")
 
 	// Healthy terminal: EnsureRun checks the persisted direct handle and,
 	// finding it live, sends no reconcile and relaunches
@@ -502,7 +502,7 @@ func TestTerminalReconcile(t *testing.T) {
 		t.Fatal(err)
 	}
 	time.Sleep(300 * time.Millisecond)
-	if log.count("inspectTerminal:") == inspectBefore {
+	if log.count("findTerminalID:") == inspectBefore {
 		t.Fatal("repeated EnsureRun never checked the persisted terminal handle")
 	}
 	if got := log.count("buildCommand:") - buildBefore; got != 0 {
@@ -792,7 +792,7 @@ func TestServeRecoverRebuildsFreshRuns(t *testing.T) {
 		RepoName: "payments", RepoPath: "/srv/payments", TicketKey: "PAY-101",
 	}
 	env, _ := fr.EnsureEnvironment(context.Background(), survSpec)
-	_, _ = fr.EnsureTerminal(context.Background(), env, "PAY-101:coding", runner.Command{})
+	_, _ = fr.EnsureTerminal(context.Background(), env, runner.Terminal{}, "PAY-101:coding", runner.Command{})
 
 	deps := goworkflows.Dependencies{Repos: repoRegistryWith("payments", sys), Runner: fr, Harness: fh}
 
@@ -821,7 +821,7 @@ func TestServeRecoverRebuildsFreshRuns(t *testing.T) {
 	if err != nil || preRuntime.TerminalID == "" {
 		t.Fatalf("pre-loss runtime = %+v, %v", preRuntime, err)
 	}
-	inspectBeforeRecover := log.count("inspectTerminal:")
+	inspectBeforeRecover := log.count("findTerminalID:")
 	pc, pcancel := context.WithTimeout(context.Background(), 30*time.Second)
 	_ = preEngine.Shutdown(pc)
 	pcancel()
@@ -871,7 +871,7 @@ func TestServeRecoverRebuildsFreshRuns(t *testing.T) {
 			t.Fatalf("%s recovery reused pre-loss terminal ID %q", key, rt.TerminalID)
 		}
 	}
-	if log.count("inspectTerminal:") != inspectBeforeRecover {
+	if log.count("findTerminalID:") != inspectBeforeRecover {
 		t.Fatalf("recover used pre-loss direct terminal IDs: %v", log.all())
 	}
 	if log.count("closeTerminals:") == 0 {

package/internal/execution/goworkflows/retry_log_test.go

@@ -6,7 +6,7 @@ import (
 )
 
 // 9.6: the info-level retry record must never embed argv payloads
-// (acli --body, orca --command carrying the agent prompt + RELAY_FLOW_*
+// (Jira/Orca request bodies or commands carrying prompts and RELAY_FLOW_*
 // env, JQL). sanitizeRetryMessage strips each "[args...]: " span while
 // preserving the surrounding wrap context and trailing stderr fragment.
 func TestSanitizeRetryMessage(t *testing.T) {
@@ -19,25 +19,25 @@ func TestSanitizeRetryMessage(t *testing.T) {
 		mustContain []string
 	}{
 		{
-			name: "acli comment with body payload",
-			in:   `acli [jira workitem comment create --key PAY-1 --body SECRET-BODY --json]: exit status 1: permission denied`,
-			mustNot: []string{"SECRET-BODY", "--body", "--key PAY-1"},
+			name:        "acli comment with body payload",
+			in:          `acli [jira workitem comment create --key PAY-1 --body SECRET-BODY --json]: exit status 1: permission denied`,
+			mustNot:     []string{"SECRET-BODY", "--body", "--key PAY-1"},
 			mustContain: []string{"acli", "exit status 1", "permission denied"},
 		},
 		{
-			name: "orca create with command payload",
-			in:   `ensure run X: orca terminal create: orca [terminal create --worktree name:PAY-1 --title PAY-1:coding --command 'RELAY_FLOW_RUN_ID=r1 opencode --agent coder PROMPT-TEXT']: exit status 1: closed`,
-			mustNot: []string{"PROMPT-TEXT", "RELAY_FLOW_RUN_ID=r1", "--command", "--title PAY-1:coding"},
+			name:        "orca create with command payload",
+			in:          `ensure run X: orca terminal create: orca [terminal create --worktree name:PAY-1 --title PAY-1:coding --command 'RELAY_FLOW_RUN_ID=r1 opencode --agent coder PROMPT-TEXT']: exit status 1: closed`,
+			mustNot:     []string{"PROMPT-TEXT", "RELAY_FLOW_RUN_ID=r1", "--command", "--title PAY-1:coding"},
 			mustContain: []string{"ensure run X", "orca terminal create", "exit status 1", "closed"},
 		},
 		{
-			name: "no brackets passes through",
-			in:   "plain failure",
+			name:        "no brackets passes through",
+			in:          "plain failure",
 			mustContain: []string{"plain failure"},
 		},
 		{
-			name: "unterminated bracket passes through",
-			in:   "weird [unterminated",
+			name:        "unterminated bracket passes through",
+			in:          "weird [unterminated",
 			mustContain: []string{"weird"},
 		},
 	}

package/internal/harness/contract_test.go

@@ -23,6 +23,8 @@ type fakeHarness struct {
 	session map[string]harness.Session // title -> session
 }
 
+var _ harness.Harness = (*fakeHarness)(nil)
+
 func newFakeHarness() *fakeHarness {
 	return &fakeHarness{
 		agents:  map[string]bool{"build": true},
@@ -141,6 +143,9 @@ func TestBuildCommandEnvContract(t *testing.T) {
 	if cmd.Env["RELAY_FLOW_TICKET"] != "PAY-101" || cmd.Env["RELAY_FLOW_NODE"] != "coding" {
 		t.Fatalf("ticket/node env wrong: %v", cmd.Env)
 	}
+	if _, ok := cmd.Env["RELAY_FLOW_NODE_VISIT_ID"]; ok {
+		t.Fatalf("internal node visit ID leaked into harness env: %v", cmd.Env)
+	}
 
 	// NEXT_STEPS_JSON must decode to the legal targets and their when
 	// explanations, not just exist.