relay-flow 0.2.2-alpha → 0.2.3-alpha

package/internal/execution/goworkflows/recovery_test.go

@@ -5,6 +5,7 @@ import (
 	"database/sql"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 	"time"
 
@@ -219,6 +220,131 @@ func TestCancelRun(t *testing.T) {
 	}
 }
 
+func TestExplicitRestartCreatesFreshAttemptFromStart(t *testing.T) {
+	log := newEventLog()
+	sys := newFakeTaskSystem(log)
+	fr := newFakeRunner(log)
+	fh := newFakeHarness(log)
+	repos := repoRegistryWith("payments", sys)
+	wf := linearWorkflow(false)
+	workflows := &workflow.Registry{}
+	workflows.Replace(&wf)
+	engine := newEngine(t, goworkflows.Dependencies{
+		Repos: repos, Runner: fr, Harness: fh,
+	})
+	oldID, err := startRun(engine, wf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	waitFor(t, 10*time.Second, func() bool {
+		r, _ := engine.GetRun(context.Background(), oldID)
+		return r.CurrentNode == "coding" && r.CurrentNodeVisitID != ""
+	})
+	if err := engine.CancelRun(context.Background(), oldID, "operator requested restart"); err != nil {
+		t.Fatal(err)
+	}
+	waitFor(t, 30*time.Second, func() bool {
+		r, _ := engine.GetRun(context.Background(), oldID)
+		return r.State == run.StateCanceled
+	})
+
+	manager := &run.RunManager{
+		Executor: engine, Runs: engine, Repos: repos, Workflows: workflows,
+	}
+	fresh, err := manager.RestartByTicket(context.Background(), "PAY-101")
+	if err != nil {
+		t.Fatalf("RestartByTicket failed: %v", err)
+	}
+	if fresh.ID == oldID || fresh.LogicalID != oldID || fresh.AttemptID != 2 {
+		t.Fatalf("fresh attempt = %+v, want logical=%q attempt=2 and a new ID", fresh, oldID)
+	}
+	oldAck, err := engine.SubmitReport(context.Background(), reportRequest(oldID, "coding", successReport("end")))
+	if err != nil || !oldAck.Accepted || !oldAck.Duplicate {
+		t.Fatalf("stale old-attempt report ack=%+v err=%v, want accepted duplicate", oldAck, err)
+	}
+	if got := string(fresh.ID); got != string(oldID)+"~attempt~2" {
+		t.Fatalf("fresh execution ID = %q, want numeric attempt suffix", got)
+	}
+	waitFor(t, 30*time.Second, func() bool {
+		r, _ := engine.GetRun(context.Background(), fresh.ID)
+		return r.CurrentNode == "coding" && r.CurrentNodeVisitID != ""
+	})
+
+	current, err := engine.GetRun(context.Background(), fresh.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	latest, err := engine.FindRunByTicket(context.Background(), "PAY-101")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if latest.ID != fresh.ID || latest.AttemptID != 2 || latest.LogicalID != oldID {
+		t.Fatalf("ticket lookup = %+v, want latest fresh attempt %q", latest, fresh.ID)
+	}
+	if current.State != run.StateWaiting && current.State != run.StateRunning {
+		t.Fatalf("fresh attempt state = %q, want active node state", current.State)
+	}
+	if got := log.count("prepareRestart:PAY-101"); got != 1 {
+		t.Fatalf("restart preparation calls = %d, want 1", got)
+	}
+	if len(fr.envs) != 1 {
+		t.Fatalf("restart created a second ticket environment: %d", len(fr.envs))
+	}
+	if fr.liveTerminals() != 1 {
+		t.Fatalf("restart left %d live terminals, want one fresh node terminal", fr.liveTerminals())
+	}
+}
+
+func TestRestartStatusConflictIsVisibleAndRecovers(t *testing.T) {
+	log := newEventLog()
+	sys := newFakeTaskSystem(log)
+	fr := newFakeRunner(log)
+	repos := repoRegistryWith("payments", sys)
+	wf := linearWorkflow(false)
+	workflows := &workflow.Registry{}
+	workflows.Replace(&wf)
+	engine := newEngine(t, goworkflows.Dependencies{Repos: repos, Runner: fr, Harness: newFakeHarness(log)})
+	oldID, err := startRun(engine, wf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	waitFor(t, 10*time.Second, func() bool {
+		r, _ := engine.GetRun(context.Background(), oldID)
+		return r.CurrentNode == "coding"
+	})
+	if err := engine.CancelRun(context.Background(), oldID, "operator requested restart"); err != nil {
+		t.Fatal(err)
+	}
+	waitFor(t, 30*time.Second, func() bool {
+		r, _ := engine.GetRun(context.Background(), oldID)
+		return r.State == run.StateCanceled
+	})
+
+	sys.setStartConflict(true)
+	manager := &run.RunManager{Executor: engine, Runs: engine, Repos: repos, Workflows: workflows}
+	fresh, err := manager.RestartByTicket(context.Background(), "PAY-101")
+	if err != nil {
+		t.Fatal(err)
+	}
+	waitFor(t, 30*time.Second, func() bool {
+		r, _ := engine.GetRun(context.Background(), fresh.ID)
+		return r.State == run.StateBlocked
+	})
+	blocked, err := engine.GetRun(context.Background(), fresh.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(blocked.LastError, "Move ticket PAY-101 to an allowed active start status") {
+		t.Fatalf("blocked LastError = %q, want actionable start-status guidance", blocked.LastError)
+	}
+
+	sys.setStartConflict(false)
+	waitFor(t, 60*time.Second, func() bool {
+		r, _ := engine.GetRun(context.Background(), fresh.ID)
+		return r.CurrentNode == "coding" && r.CurrentNodeVisitID != ""
+	})
+}
+
 func TestCancelDuringRunningActivity(t *testing.T) {
 	// Cancellation cannot interrupt an already-running activity; it waits
 	// for it to return, then runs cancellation cleanup.
@@ -444,6 +570,9 @@ func TestConflictMarksBlockedThenRecovers(t *testing.T) {
 	if r.LastError == "" {
 		t.Fatal("blocked run exposes no conflict error in LastError")
 	}
+	if !strings.Contains(r.LastError, "Restore the task-system state required for node coding") {
+		t.Fatalf("blocked LastError = %q, want actionable node-state guidance", r.LastError)
+	}
 	if sys.mailboxStatusOf("PAY-101-coding") == "Done" {
 		t.Fatal("mailbox completed while state was incompatible; no blind overwrite allowed")
 	}

package/internal/harness/opencode/opencode.go

@@ -30,7 +30,7 @@ Use the {{taskSystem}} tools to read the parent ticket {{ticket}}.
 
 Your mailbox is {{mailbox}}. Read its description and comments for node instructions and feedback.`
 	defaultFeedbackPrompt = `New feedback was added to the comments section of your mailbox subtask {{mailbox}}. Read it.`
-	defaultHITLPrompt     = `Before submitting your report, present the complete proposed report through OpenCode's built-in Question tool with exactly two options: Approve and Reject. Submit it only after an explicit Approve answer.`
+	defaultHITLPrompt     = `Return the complete report directly. Relay-flow will show a native TUI approval dialog after the report is valid. Do not use OpenCode's Question tool for relay-flow approval.`
 )
 
 var promptVarPattern = regexp.MustCompile(`\{\{([^{}]*)\}\}`)
@@ -133,9 +133,9 @@ func (h *Harness) FindSession(context.Context, string, string) (harness.Session,
 	return harness.Session{}, false, nil
 }
 
-// RenderPrompt renders the selected session prompt, appends HITL approval
-// instructions for HITL nodes, then renders and appends the node's nudge
-// template.
+// RenderPrompt renders the selected session prompt, appends the harness-owned
+// HITL/TUI instructions for HITL nodes, then renders and appends the node's
+// nudge template.
 func (h *Harness) RenderPrompt(kind harness.PromptKind, data harness.PromptData, nudgeTemplate string) (string, error) {
 	var tmpl string
 	switch kind {

package/internal/harness/opencode/opencode_test.go

@@ -14,7 +14,7 @@ import (
 	"github.com/rajpopat27/relay-flow/internal/workflow"
 )
 
-const configuredPlugin = "relay-flow-plugin@0.2.2-alpha"
+const configuredPlugin = "relay-flow-plugin@0.2.3-alpha"
 
 func TestBuildCommandArgv(t *testing.T) {
 	t.Setenv("RELAY_FLOW_HOME", "/var/lib/relay-flow-test")
@@ -61,7 +61,6 @@ func TestRenderPromptTemplatesExposeAllValues(t *testing.T) {
 	raw := config.RawValues{
 		"initial":  "initial {{taskSystem}}|{{ticket}}|{{workflow}}|{{repo}}|{{node}}|{{nodeType}}|{{agent}}|{{nodeDescription}}|{{nextSteps}}|{{mailbox}}",
 		"feedback": "feedback {{mailbox}}",
-		"hitl":     "hitl {{node}}",
 	}
 	h, err := harness.New("opencode", raw)
 	if err != nil {
@@ -77,7 +76,7 @@ func TestRenderPromptTemplatesExposeAllValues(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	wantInitial := "initial linear|PAY-101|basicFlow|payments|review|hitl|build|Review it.|end (when: approved)|PAY-234\n\nhitl review\n\nnudge linear|PAY-101|basicFlow|payments|review|end (when: approved)"
+	wantInitial := "initial linear|PAY-101|basicFlow|payments|review|hitl|build|Review it.|end (when: approved)|PAY-234\n\nReturn the complete report directly. Relay-flow will show a native TUI approval dialog after the report is valid. Do not use OpenCode's Question tool for relay-flow approval.\n\nnudge linear|PAY-101|basicFlow|payments|review|end (when: approved)"
 	if initial != wantInitial {
 		t.Fatalf("initial prompt = %q, want %q", initial, wantInitial)
 	}
@@ -85,7 +84,7 @@ func TestRenderPromptTemplatesExposeAllValues(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if want := "feedback PAY-234\n\nhitl review\n\nnudge linear|PAY-101|basicFlow|payments|review|end (when: approved)"; feedback != want {
+	if want := "feedback PAY-234\n\nReturn the complete report directly. Relay-flow will show a native TUI approval dialog after the report is valid. Do not use OpenCode's Question tool for relay-flow approval.\n\nnudge linear|PAY-101|basicFlow|payments|review|end (when: approved)"; feedback != want {
 		t.Fatalf("feedback prompt = %q, want %q", feedback, want)
 	}
 }
@@ -206,6 +205,62 @@ func TestSetupRepoAddsPluginPropertyToJSONCWithComments(t *testing.T) {
 	}
 }
 
+func TestSetupRepoCreatesOpenCodeTUIConfig(t *testing.T) {
+	dir := t.TempDir()
+	if err := opencode.New().SetupRepo(t.Context(), dir); err != nil {
+		t.Fatalf("SetupRepo: %v", err)
+	}
+	path := filepath.Join(dir, ".opencode", "tui.json")
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var cfg struct {
+		Schema string   `json:"$schema"`
+		Plugin []string `json:"plugin"`
+	}
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		t.Fatalf("created TUI config is invalid JSON: %v\n%s", err, data)
+	}
+	if cfg.Schema != "https://opencode.ai/tui.json" {
+		t.Fatalf("$schema = %q", cfg.Schema)
+	}
+	if !reflect.DeepEqual(cfg.Plugin, []string{configuredPlugin}) {
+		t.Fatalf("plugin = %v", cfg.Plugin)
+	}
+}
+
+func TestSetupRepoUpdatesExistingOpenCodeTUIJSONC(t *testing.T) {
+	dir := t.TempDir()
+	configDir := filepath.Join(dir, ".opencode")
+	if err := os.MkdirAll(configDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(configDir, "tui.jsonc")
+	original := `{
+  // keep the local theme
+  "theme": "catppuccin"
+}
+`
+	if err := os.WriteFile(path, []byte(original), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := opencode.New().SetupRepo(t.Context(), dir); err != nil {
+		t.Fatalf("SetupRepo: %v", err)
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(data)
+	if !strings.Contains(text, "// keep the local theme") || !strings.Contains(text, configuredPlugin) {
+		t.Fatalf("TUI config was not preserved and updated:\n%s", text)
+	}
+	if _, err := os.Stat(filepath.Join(configDir, "tui.json")); !os.IsNotExist(err) {
+		t.Fatalf("unexpected tui.json created: %v", err)
+	}
+}
+
 func setupTwice(t *testing.T, dir string) {
 	t.Helper()
 	h := opencode.New()

package/internal/harness/opencode/repo_setup.go

@@ -10,7 +10,7 @@ import (
 	"github.com/rajpopat27/relay-flow/internal/config"
 )
 
-const relayFlowPlugin = "relay-flow-plugin@0.2.2-alpha"
+const relayFlowPlugin = "relay-flow-plugin@0.2.3-alpha"
 
 type jsoncToken struct {
 	kind       byte
@@ -47,12 +47,34 @@ func setupRepo(repoPath string) error {
 	if err != nil {
 		return err
 	}
+	if err := ensurePluginConfig(path, mode, ""); err != nil {
+		return err
+	}
+
+	tuiPath, tuiMode, err := openCodeTUIConfigPath(repoPath)
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(filepath.Dir(tuiPath), 0o755); err != nil {
+		return fmt.Errorf("opencode: create TUI config directory: %w", err)
+	}
+	if err := ensurePluginConfig(tuiPath, tuiMode, "https://opencode.ai/tui.json"); err != nil {
+		return fmt.Errorf("opencode: setup TUI config: %w", err)
+	}
+	return nil
+}
+
+func ensurePluginConfig(path string, mode os.FileMode, schema string) error {
 	data, err := os.ReadFile(path)
 	if err != nil {
 		if !os.IsNotExist(err) {
 			return fmt.Errorf("opencode: read %s: %w", path, err)
 		}
-		data = []byte("{\n  \"plugin\": [\"" + relayFlowPlugin + "\"]\n}\n")
+		if schema == "" {
+			data = []byte("{\n  \"plugin\": [\"" + relayFlowPlugin + "\"]\n}\n")
+		} else {
+			data = []byte("{\n  \"$schema\": \"" + schema + "\",\n  \"plugin\": [\"" + relayFlowPlugin + "\"]\n}\n")
+		}
 	} else {
 		data, err = updateOpenCodeConfig(data)
 		if err != nil {
@@ -86,6 +108,24 @@ func openCodeConfigPath(repoPath string) (string, os.FileMode, error) {
 	return jsonPath, 0o644, nil
 }
 
+func openCodeTUIConfigPath(repoPath string) (string, os.FileMode, error) {
+	dir := filepath.Join(repoPath, ".opencode")
+	for _, name := range []string{"tui.json", "tui.jsonc"} {
+		path := filepath.Join(dir, name)
+		info, err := os.Stat(path)
+		if err == nil {
+			if !info.Mode().IsRegular() {
+				return "", 0, fmt.Errorf("opencode: TUI config %s is not a regular file", path)
+			}
+			return path, info.Mode().Perm(), nil
+		}
+		if !os.IsNotExist(err) {
+			return "", 0, fmt.Errorf("opencode: inspect TUI config %s: %w", path, err)
+		}
+	}
+	return filepath.Join(dir, "tui.json"), 0o644, nil
+}
+
 func updateOpenCodeConfig(data []byte) ([]byte, error) {
 	tokens, err := tokenizeJSONC(data)
 	if err != nil {

package/internal/identity/identity.go

@@ -6,12 +6,18 @@ import (
 	"crypto/rand"
 	"encoding/hex"
 	"net/url"
+	"strconv"
 	"strings"
 )
 
-// RunID identifies one durable run. Opaque to consumers.
+// RunID identifies one durable execution attempt. Opaque to consumers.
 type RunID string
 
+// AttemptID identifies an execution generation for one logical
+// repo/workflow/ticket run. Attempt numbers are durably allocated by the Run
+// Manager and are intentionally simple numeric values.
+type AttemptID uint64
+
 // NodeVisitID identifies one entry into a workflow node. Opaque to consumers.
 type NodeVisitID string
 
@@ -25,6 +31,27 @@ func NewRunID(repo, workflow, ticket string) RunID {
 	}, "/"))
 }
 
+// NewAttemptRunID derives an execution ID that is fenced from the stable
+// logical run ID. Attempt 1 retains the original deterministic ID for the
+// first execution; explicit restarts use numeric attempt suffixes.
+func NewAttemptRunID(logical RunID, attempt AttemptID) RunID {
+	if attempt <= 1 {
+		return logical
+	}
+	return RunID(string(logical) + "~attempt~" + strconv.FormatUint(uint64(attempt), 10))
+}
+
+// LogicalRunID returns the stable logical ID embedded in an execution ID.
+// First attempts are already logical IDs; explicit attempts use the
+// `~attempt~<number>` suffix generated by NewAttemptRunID.
+func LogicalRunID(execution RunID) RunID {
+	const marker = "~attempt~"
+	if index := strings.LastIndex(string(execution), marker); index >= 0 {
+		return RunID(string(execution)[:index])
+	}
+	return execution
+}
+
 // NewNodeVisitID returns a fresh random node-visit ID. Generation happens
 // once per node entry as a durable replay-safe side effect; this function
 // only produces the random value.

package/internal/identity/identity_test.go

@@ -0,0 +1,40 @@
+package identity_test
+
+import (
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/identity"
+)
+
+func TestAttemptRunIDUsesNumericAttemptSuffix(t *testing.T) {
+	logical := identity.NewRunID("payments", "basicFlow", "PAY-101")
+
+	if got := identity.NewAttemptRunID(logical, 1); got != logical {
+		t.Fatalf("initial attempt ID = %q, want logical ID %q", got, logical)
+	}
+	if got := identity.NewAttemptRunID(logical, 2); got != logical+"~attempt~2" {
+		t.Fatalf("restart attempt ID = %q, want numeric suffix", got)
+	}
+	if got := identity.NewAttemptRunID(logical, 3); got == identity.NewAttemptRunID(logical, 2) {
+		t.Fatalf("attempt IDs are not fenced: attempt 2 and 3 both use %q", got)
+	}
+}
+
+func TestAttemptIDsAreNumeric(t *testing.T) {
+	var first identity.AttemptID = 1
+	var second identity.AttemptID = 2
+	if first != 1 || second != 2 {
+		t.Fatalf("attempt IDs are not numeric: %d, %d", first, second)
+	}
+}
+
+func TestLogicalRunIDStripsAttemptSuffix(t *testing.T) {
+	logical := identity.NewRunID("payments", "basicFlow", "PAY-101")
+	execution := identity.NewAttemptRunID(logical, 4)
+	if got := identity.LogicalRunID(execution); got != logical {
+		t.Fatalf("logical ID = %q, want %q", got, logical)
+	}
+	if got := identity.LogicalRunID(logical); got != logical {
+		t.Fatalf("first-attempt logical ID = %q, want %q", got, logical)
+	}
+}