From f3e0593f4df66274046385a3d39f70e5cb7cf706 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Fri, 16 Oct 2026 13:35:43 +0100 Subject: [PATCH] Let runs carry an operator title shown in the CLI and TUI Add a bounded, never-empty title to every run. `pipelines run --title "..."` sets it explicitly and skips model generation; otherwise the server generates it from the prompt through the shared summariser and falls back to the prompt's first line, recording title_source (model/fallback/explicit) and title_model. - protocol/store: RunSummary.Title plus Label(), a set_run_title message, title columns with an idempotent migration, CreateRunTitled, and SetRunTitle renames. - summarise: Title/GenerateTitle/DeriveTitle/ExplicitTitle bounded to TitleCap. - runner: generate the title outside the admission lock and only for a request that starts a run; a replay reuses the stored title and an explicit title skips the model entirely. - CLI: `--title` on run and a `title ""` rename command; human `runs` and `inspect` show the title beside the pipeline name and version. - TUI: the run list row, run detail header, Home run cards and last-run line, and the pipeline Results line show the title via Label(). Tests cover storage/migration/fallback, explicit-title and rename, the end-to-end CLI flow, and title rendering; CLI and operations docs updated. --- README.md | 4 + cmd/pipelines-server/main.go | 6 +- docs/cli.md | 15 +- .../author/skill/references/operations.md | 12 +- internal/cli/app.go | 43 ++-- internal/cli/commands.go | 6 +- internal/cli/help.go | 1 + internal/pipeline/runs.go | 97 ++++++++- internal/pipeline/runs_test.go | 123 ++++++++++++ internal/protocol/message.go | 1 + internal/protocol/runs.go | 30 ++- internal/server/cli_test.go | 102 ++++++++++ internal/server/runner.go | 94 +++++++-- internal/server/runner_test.go | 186 ++++++++++++++++++ internal/server/websocket.go | 13 +- internal/summarise/summarise.go | 138 ++++++++++--- internal/summarise/summarise_test.go | 81 ++++++++ internal/tui/cli_run.go | 6 +- internal/tui/dashboard.go | 4 +- internal/tui/results.go | 2 +- internal/tui/run_detail.go | 6 +- internal/tui/runs.go | 2 +- internal/tui/runs_test.go | 18 ++ 23 files changed, 916 insertions(+), 74 deletions(-) diff --git a/README.md b/README.md index 693e69e8..26aed391 100644 --- a/README.md +++ b/README.md @@ -344,6 +344,10 @@ Retries restart at the entry stage with fresh OpenCode sessions, never the previ conversation or intermediate stage output. Pipelines does not automatically delete generation, agent, or formatting-repair sessions, including on failure/cancellation. Primary session IDs are retained in run steps (`pipelines inspect <run-id> --json`). +Every run also records a short, single-line title: `pipelines run ... --title "…"` +sets one explicitly, otherwise it is generated from the prompt. `pipelines runs` +and `pipelines inspect` show it beside the pipeline name and version, and +`pipelines title <run-id> "…"` renames it afterwards. On Home, **r** opens global run history; **/** fuzzy-searches it. Inside a pipeline, **r** / **:runs** opens only that pipeline's history. Quit the TUI with **:quit**; **q** does not exit. **Ctrl+C** remains an interrupt. diff --git a/cmd/pipelines-server/main.go b/cmd/pipelines-server/main.go index 1d2e4408..763523ad 100644 --- a/cmd/pipelines-server/main.go +++ b/cmd/pipelines-server/main.go @@ -16,6 +16,7 @@ import ( "git.a-wan.net/alan/pipelines/internal/paths" "git.a-wan.net/alan/pipelines/internal/pipeline" "git.a-wan.net/alan/pipelines/internal/server" + "git.a-wan.net/alan/pipelines/internal/summarise" ) func main() { @@ -37,7 +38,10 @@ func main() { ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM) defer stop() artifactsRoot := filepath.Join(filepath.Dir(*db), "artifacts") - options := server.Options{ArtifactsRoot: artifactsRoot} + // Each new run gets a bounded one-line title from the configured default + // harness; the summariser falls back to the prompt's first line, so title + // generation never blocks or fails run creation. + options := server.Options{ArtifactsRoot: artifactsRoot, RunTitles: summarise.GenerateTitle} // Chat brokers OpenCode over the owned endpoint. Streaming needs a // URL-bearing, SSE-capable backend. Detect may select "v2" (the CLI // advertises `api`), but Open never starts a serve process for v2 and so diff --git a/docs/cli.md b/docs/cli.md index efce5665..6d82f6ac 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -198,8 +198,9 @@ Submitting activates included schedules, so review them before publishing. | Browse templates/source | `templates --json`, `template KEY --source` | | Create or edit a definition | `new`, `edit`, `drafts` | | Validate and publish | `validate FILE`, `submit FILE` | -| Start a run | `run NAME PROMPT --yes --json` | +| Start a run | `run NAME PROMPT [--title TITLE] --yes --json` | | Run history/inspection | `runs --json`, `inspect ID --json` | +| Rename a run | `title ID "TITLE" --json` | | Cancel | `cancel ID --json` | | Connection and phone settings | `connection --json`, `ping --json` | | Server/ntfy status popup | `status --json` | @@ -224,6 +225,18 @@ transient client logs are presentation, not separate server capabilities. ## Scripted runs +Every run records a short, single-line `title` saying what it was for. `pipelines +run --title "..."` sets it explicitly; otherwise the server generates it from the +prompt with the configured default harness. It is never empty: when generation is +unavailable or times out, the server derives the prompt's first line, and +`title_source` (`model`, `fallback`, or `explicit` for an operator-set title) plus +`title_model` record how it was produced so a diagnosis can tell them apart. +`pipelines runs` shows the title beside the pipeline name and version, and +`pipelines inspect` returns the title, name and version, so two runs of one +pipeline are distinguishable. Rename after the fact with `pipelines title +<run-id> "<title>"`; the run's input, steps and execution are unchanged. The +stored prompt is unchanged, and listing/renaming never calls a model. + On either the runs list or run inspector, press `P` (or use `:pipeline`) to open the selected run's exact pipeline version. Navigation does not cancel the run. diff --git a/internal/author/skill/references/operations.md b/internal/author/skill/references/operations.md index 44273aba..c128fe5f 100644 --- a/internal/author/skill/references/operations.md +++ b/internal/author/skill/references/operations.md @@ -70,7 +70,17 @@ delete databases, sessions, volumes or credentials to repair a workflow. Use the authoritative `CLI_PREFIX` from the prompt: -- `CLI_PREFIX runs --json`: run history (optional `--pipeline NAME` scope). +- `CLI_PREFIX runs --json`: run history (optional `--pipeline NAME` scope). Each run + carries a bounded, single-line `title` saying what it was for, set explicitly with + `CLI_PREFIX run ... --title "..."` or generated from its prompt by the shared + summariser on the configured default harness. It is never empty: when generation is + unavailable or times out the server derives the prompt's first line, and + `title_source` (`model`, `fallback`, or `explicit`) plus `title_model` record how it + was produced, so a diagnosis can tell them apart. Human `runs` and `inspect` show the + title beside the pipeline name and version, so two runs of one pipeline are + distinguishable; `CLI_PREFIX title RUN_ID "..."` renames a run after the fact + without changing its input or steps. The stored prompt is unchanged, and + listing/renaming never calls a model. - `CLI_PREFIX inspect RUN_ID --json`: selected run, visits and retained evidence. Exact stage outputs are authoritative; a transcript over the 32 KiB retained bound is a valid, credential-redacted preview envelope (with preserved stage diff --git a/internal/cli/app.go b/internal/cli/app.go index de310df8..32af9102 100644 --- a/internal/cli/app.go +++ b/internal/cli/app.go @@ -33,14 +33,14 @@ type App struct { In io.Reader } type options struct { - harness string - url, name, prompt, template, workspace, paths, key, opencode, model string - output string - conflict string - all bool - json, source, noOpen, yes, allow, createOnly, force, wait bool - version, expected int - timeout, waitTimeout time.Duration + harness string + url, name, prompt, title, template, workspace, paths, key, opencode, model string + output string + conflict string + all bool + json, source, noOpen, yes, allow, createOnly, force, wait bool + version, expected int + timeout, waitTimeout time.Duration } func (a App) flags(command string) (*flag.FlagSet, *options) { @@ -89,6 +89,7 @@ func (a App) flags(command string) (*flag.FlagSet, *options) { case "run": f.StringVar(&o.name, "pipeline", "", "Exact registered pipeline name or ID") f.StringVar(&o.prompt, "prompt", "", "Task prompt; omitted opens a multiline composer") + f.StringVar(&o.title, "title", "", "Explicit run title; default is derived from the prompt") f.StringVar(&o.workspace, "workspace", "", "Run directory (default: current directory)") f.BoolVar(&o.yes, "yes", false, "Confirm execution without an interactive prompt") f.BoolVar(&o.allow, "allow-tools", false, "Compatibility flag; stage-declared tools are enabled automatically") @@ -658,7 +659,7 @@ func (a App) Run(ctx context.Context, args []string) error { } case "runs": for _, run := range r.Runs { - fmt.Fprintf(a.Out, "%d\t%s\tv%d\t%s\n", run.ID, run.Name, run.Version, run.Status) + fmt.Fprintf(a.Out, "%d\t%s\t%s\tv%d\t%s\n", run.ID, run.Label(), run.Name, run.Version, run.Status) } case "ping": fmt.Fprintln(a.Out, "Connected ·", r.Time) @@ -777,6 +778,26 @@ func (a App) Run(ctx context.Context, args []string) error { return a.finishRun(ctx, r, o, call) } return a.output(r.RunDetail) + case "title": + if len(pos) != 2 { + return fmt.Errorf("title requires a run ID and a title") + } + id, err := strconv.ParseInt(pos[0], 10, 64) + if err != nil || id <= 0 { + return fmt.Errorf("run ID must be positive") + } + r, err := call(protocol.Message{Type: protocol.SetRunTitle, RunID: id, Title: pos[1]}) + if err != nil { + return err + } + if r.RunDetail == nil { + return fmt.Errorf("server did not return run detail") + } + if o.json { + return a.output(r.RunDetail) + } + _, err = fmt.Fprintf(a.Out, "Renamed run #%d to %s\n", r.RunDetail.ID, r.RunDetail.Label()) + return err case "rpc": path, err := one() if err != nil { @@ -995,7 +1016,7 @@ func (a App) run(ctx context.Context, pos []string, o *options, call callFunc, r if o.wait || o.key != "" || o.version > 0 { return fmt.Errorf("--wait, --request-key and --version require --json") } - _, err := tea.NewProgram(tui.NewRun(ctx, o.url, tui.RunOptions{Pipeline: o.name, Prompt: o.prompt, Workspace: workspace, Yes: o.yes, AllowTools: o.allow, WritePaths: paths}), tea.WithContext(ctx), tea.WithAltScreen()).Run() + _, err := tea.NewProgram(tui.NewRun(ctx, o.url, tui.RunOptions{Pipeline: o.name, Prompt: o.prompt, Title: o.title, Workspace: workspace, Yes: o.yes, AllowTools: o.allow, WritePaths: paths}), tea.WithContext(ctx), tea.WithAltScreen()).Run() return err } if o.name == "" || strings.TrimSpace(o.prompt) == "" { @@ -1016,7 +1037,7 @@ func (a App) run(ctx context.Context, pos []string, o *options, call callFunc, r if key == "" { key = fmt.Sprintf("cli-%d-%d", os.Getpid(), time.Now().UnixNano()) } - r, err := call(protocol.Message{Type: protocol.RunPipeline, PipelineID: p.ID, Version: version, RequestKey: key, Workspace: workspace, Input: map[string]any{"prompt": o.prompt}, AllowTools: o.allow, WritePaths: paths}) + r, err := call(protocol.Message{Type: protocol.RunPipeline, PipelineID: p.ID, Version: version, RequestKey: key, Workspace: workspace, Title: o.title, Input: map[string]any{"prompt": o.prompt}, AllowTools: o.allow, WritePaths: paths}) if err != nil { return err } diff --git a/internal/cli/commands.go b/internal/cli/commands.go index ba79a79a..20c90b4a 100644 --- a/internal/cli/commands.go +++ b/internal/cli/commands.go @@ -16,11 +16,12 @@ var usage = map[string]string{ "import": "import [FILE.zip] [--all] [--on-conflict ask|keep|both|import] [--yes] [--json]", "templates": "templates [--json]", "template": "template <key> [--source | --json]", - "run": "run [name|id] [prompt] [--json [--wait [--wait-timeout DURATION]]]", + "run": "run [name|id] [prompt] [--title TITLE] [--json [--wait [--wait-timeout DURATION]]]", "runs": "runs [--pipeline NAME] [--json]", "inspect": "inspect <run-id> [--json]", "cancel": "cancel <run-id> [--json]", "retry": "retry <run-id> [--json [--wait [--wait-timeout DURATION]]]", + "title": "title <run-id> \"<title>\" [--json]", "debug": "debug <run-id> [--json | --no-open]", "connection": "connection [--json]", "ping": "ping [--json]", @@ -40,8 +41,9 @@ var notes = map[string]string{ "edit": "Omit the name to open fuzzy selection. Original immutable source is copied to a private draft. The configured harness edits that draft, never the live definition.", "validate": "Uses the same server parser as submission. Does not persist or activate schedules. Structural validity does not prove runtime/tool availability.", "submit": "Confirm publication at the prompt, or use --yes for explicit automation; schedules activate on acceptance. Managed drafts provide the name and base-version guard. --force never bypasses validation.", - "run": "Runs in your current directory after action confirmation (--yes skips it). Select a pipeline and compose a multiline task with Ctrl+S. Stage tools are enabled automatically; no file list or typed RUN confirmation. Cancellation does not undo edits. In JSON mode --wait polls until terminal; --wait-timeout bounds only the client wait after admission and is independent of per-request --timeout. A reached wait limit leaves the run active: inspect read-only with `inspect <run-id> --json`, or reattach with --wait reusing the original --request-key (never an automatic replay or cancel).", + "run": "Runs in your current directory after action confirmation (--yes skips it). Select a pipeline and compose a multiline task with Ctrl+S. Stage tools are enabled automatically; no file list or typed RUN confirmation. Cancellation does not undo edits. --title sets an explicit run title; without it the title is derived from the prompt. In JSON mode --wait polls until terminal; --wait-timeout bounds only the client wait after admission and is independent of per-request --timeout. A reached wait limit leaves the run active: inspect read-only with `inspect <run-id> --json`, or reattach with --wait reusing the original --request-key (never an automatic replay or cancel).", "retry": "Start a new attempt of a failed run with the same initial input, directory, pipeline version, and edit scope. Original history is retained. Already-completed side effects are not undone. --wait/--wait-timeout behave as for run: a reached wait limit leaves the new run active; inspect read-only with `inspect <run-id> --json`, or reattach with --wait and the original --request-key instead of starting a duplicate retry.", + "title": "Rename a run's operator-facing title after the fact without touching its input, steps or execution. The title is collapsed to a single bounded line and recorded as explicitly set. `pipelines runs` and `pipelines inspect` then show it.", "debug": "Open a fresh configured harness conversation to investigate a run using inspect/show/runs CLI queries. --harness opencode|pi|nvim chooses another configured harness or read-only nvim packet. Does not resume implementation or retry. --json returns the prompt without launching anything.", "rpc": "Accepts a JSON protocol envelope; '-' reads stdin. Every TUI server operation is available here too. Mutating commands are not dry runs.", } diff --git a/internal/cli/help.go b/internal/cli/help.go index d0090b87..4f53d791 100644 --- a/internal/cli/help.go +++ b/internal/cli/help.go @@ -27,6 +27,7 @@ EXECUTE inspect <run-id> Inspect stages, outputs, errors and status cancel <run-id> Cancel a run; changes are NOT rolled back retry <run-id> Restart a failed run with its original input and directory + title <run-id> "<title>" Rename a run after the fact; input/steps unchanged debug <run-id> Investigate a run with a configured harness or nvim draft-delete <draft.md> Delete a selected retained draft and its metadata connection Server and public phone connection (no secrets) diff --git a/internal/pipeline/runs.go b/internal/pipeline/runs.go index 03c8ca6f..bde35679 100644 --- a/internal/pipeline/runs.go +++ b/internal/pipeline/runs.go @@ -6,15 +6,18 @@ import ( "database/sql" "encoding/json" "fmt" + "strings" "git.a-wan.net/alan/pipelines/internal/protocol" "git.a-wan.net/alan/pipelines/internal/stage" + "git.a-wan.net/alan/pipelines/internal/summarise" ) func (s *Store) initRuns() error { _, err := s.db.Exec(`CREATE TABLE IF NOT EXISTS pipeline_runs ( id INTEGER PRIMARY KEY, pipeline_id INTEGER NOT NULL, version INTEGER NOT NULL, request_key TEXT NOT NULL UNIQUE, workspace TEXT NOT NULL, allow_tools INTEGER NOT NULL, +title TEXT NOT NULL DEFAULT '', title_source TEXT NOT NULL DEFAULT '', title_model TEXT NOT NULL DEFAULT '', write_paths TEXT NOT NULL, input_json TEXT NOT NULL, output_json TEXT NOT NULL DEFAULT '{}', status TEXT NOT NULL DEFAULT 'queued', outcome TEXT NOT NULL DEFAULT '', current_stage TEXT NOT NULL DEFAULT '', diagnostic TEXT NOT NULL DEFAULT '', created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, finished_at TEXT, @@ -44,10 +47,65 @@ run_id INTEGER NOT NULL, sequence INTEGER NOT NULL, backend TEXT NOT NULL, refer PRIMARY KEY(run_id,sequence), FOREIGN KEY(run_id,sequence) REFERENCES run_steps(run_id,sequence)); CREATE TABLE IF NOT EXISTS run_retries ( run_id INTEGER PRIMARY KEY REFERENCES pipeline_runs(id), original_run_id INTEGER NOT NULL REFERENCES pipeline_runs(id));`) + if err != nil { + return err + } + return s.migrateRunTitles() +} + +// migrateRunTitles adds the title columns to a database created before run +// titles existed. Adding a column with a default leaves every existing row valid +// and untouched, so old runs still list. +func (s *Store) migrateRunTitles() error { + for _, column := range [][2]string{ + {"title", "TEXT NOT NULL DEFAULT ''"}, + {"title_source", "TEXT NOT NULL DEFAULT ''"}, + {"title_model", "TEXT NOT NULL DEFAULT ''"}, + } { + if err := s.addColumnIfMissing("pipeline_runs", column[0], column[1]); err != nil { + return err + } + } + return nil +} + +// addColumnIfMissing adds a column only when the table predates it, making an +// upgrade idempotent across repeated Open calls without rewriting history. +func (s *Store) addColumnIfMissing(table, column, definition string) error { + rows, err := s.db.Query("PRAGMA table_info(" + table + ")") + if err != nil { + return err + } + defer rows.Close() + for rows.Next() { + var cid, notnull, pk int + var name, ctype string + var dflt sql.NullString + if err := rows.Scan(&cid, &name, &ctype, ¬null, &dflt, &pk); err != nil { + return err + } + if name == column { + return nil + } + } + if err := rows.Err(); err != nil { + return err + } + _, err = s.db.Exec("ALTER TABLE " + table + " ADD COLUMN " + column + " " + definition) return err } +// CreateRun inserts a run and derives its title from the prompt. It is the entry +// point for callers with no generated title; the derived fallback is always +// non-empty and never calls a model. func (s *Store) CreateRun(ctx context.Context, d *protocol.PipelineDetail, key, workspace string, tools bool, paths []string, input map[string]any, retryOf ...int64) (int64, bool, error) { + return s.CreateRunTitled(ctx, d, key, workspace, tools, paths, input, summarise.Title{}, retryOf...) +} + +// CreateRunTitled inserts a run with the caller's title. A non-empty title (a +// model generation) is stored verbatim; an empty one falls back to the +// prompt-derived title, so a run never stores an empty title. +func (s *Store) CreateRunTitled(ctx context.Context, d *protocol.PipelineDetail, key, workspace string, tools bool, paths []string, input map[string]any, title summarise.Title, retryOf ...int64) (int64, bool, error) { var parent int64 if len(retryOf) > 0 { parent = retryOf[0] @@ -55,6 +113,7 @@ func (s *Store) CreateRun(ctx context.Context, d *protocol.PipelineDetail, key, if parent < 0 { return 0, false, fmt.Errorf("invalid retry parent") } + title = resolveRunTitle(title, input) encoded, err := json.Marshal(input) if err != nil { return 0, false, err @@ -88,7 +147,7 @@ func (s *Store) CreateRun(ctx context.Context, d *protocol.PipelineDetail, key, return 0, false, err } defer tx.Rollback() - result, err := tx.ExecContext(ctx, "INSERT INTO pipeline_runs(pipeline_id,version,request_key,workspace,allow_tools,write_paths,input_json) VALUES (?,?,?,?,?,?,?)", d.ID, d.Version, key, workspace, tools, string(writes), string(encoded)) + result, err := tx.ExecContext(ctx, "INSERT INTO pipeline_runs(pipeline_id,version,request_key,workspace,allow_tools,write_paths,input_json,title,title_source,title_model) VALUES (?,?,?,?,?,?,?,?,?,?)", d.ID, d.Version, key, workspace, tools, string(writes), string(encoded), title.Text, title.Source, title.Model) if err != nil { return 0, false, err } @@ -107,15 +166,45 @@ func (s *Store) CreateRun(ctx context.Context, d *protocol.PipelineDetail, key, return id, true, nil } +// resolveRunTitle guarantees a stored run title is never empty: a title supplied +// by the caller (a model generation) is kept verbatim, and an absent one is +// derived from the prompt's first line. The fallback is server-owned and never +// calls a model, so it can never block or fail run creation. +func resolveRunTitle(title summarise.Title, input map[string]any) summarise.Title { + if strings.TrimSpace(title.Text) != "" { + return title + } + prompt, _ := input["prompt"].(string) + return summarise.Title{Text: summarise.DeriveTitle(prompt), Source: summarise.SourceFallback} +} + +// SetRunTitle replaces a run's operator-facing title and its provenance without +// touching the run's input, steps or execution. It is how an operator renames a +// run after the fact. +func (s *Store) SetRunTitle(ctx context.Context, id int64, title summarise.Title) error { + result, err := s.db.ExecContext(ctx, "UPDATE pipeline_runs SET title=?,title_source=?,title_model=? WHERE id=?", title.Text, title.Source, title.Model, id) + if err != nil { + return err + } + n, err := result.RowsAffected() + if err != nil { + return err + } + if n != 1 { + return fmt.Errorf("run not found") + } + return nil +} + const runSelect = `SELECT r.id,r.pipeline_id,p.name,r.version,v.content_hash,r.status,r.outcome,r.current_stage, strftime('%Y-%m-%dT%H:%M:%SZ',r.created_at),COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ',r.finished_at),''),r.diagnostic, CASE WHEN r.status='succeeded' THEN r.output_json ELSE COALESCE((SELECT output_json FROM run_steps WHERE run_id=r.id AND status='completed' ORDER BY sequence DESC LIMIT 1),'{}') END, -(SELECT COUNT(*) FROM run_steps WHERE run_id=r.id AND status='completed') +(SELECT COUNT(*) FROM run_steps WHERE run_id=r.id AND status='completed'),r.workspace,r.title FROM pipeline_runs r JOIN pipelines p ON p.id=r.pipeline_id JOIN pipeline_versions v ON v.pipeline_id=r.pipeline_id AND v.version=r.version` func scanRun(row interface{ Scan(...any) error }, r *protocol.RunSummary) error { var output string - if err := row.Scan(&r.ID, &r.PipelineID, &r.Name, &r.Version, &r.ContentHash, &r.Status, &r.Outcome, &r.CurrentStage, &r.CreatedAt, &r.FinishedAt, &r.Diagnostic, &output, &r.CompletedSteps); err != nil { + if err := row.Scan(&r.ID, &r.PipelineID, &r.Name, &r.Version, &r.ContentHash, &r.Status, &r.Outcome, &r.CurrentStage, &r.CreatedAt, &r.FinishedAt, &r.Diagnostic, &output, &r.CompletedSteps, &r.Workspace, &r.Title); err != nil { return err } var values map[string]any @@ -179,7 +268,7 @@ func (s *Store) GetRun(ctx context.Context, id int64) (*protocol.RunDetail, erro if err := json.Unmarshal([]byte(graphJSON), &r.Graph); err != nil { return nil, err } - if err := tx.QueryRowContext(ctx, "SELECT workspace,allow_tools,write_paths,input_json,output_json,COALESCE((SELECT original_run_id FROM run_retries WHERE run_id=pipeline_runs.id),0) FROM pipeline_runs WHERE id=?", id).Scan(&r.Workspace, &r.AllowTools, &paths, &input, &output, &r.RetryOf); err != nil { + if err := tx.QueryRowContext(ctx, "SELECT workspace,allow_tools,write_paths,input_json,output_json,COALESCE((SELECT original_run_id FROM run_retries WHERE run_id=pipeline_runs.id),0),title_source,title_model FROM pipeline_runs WHERE id=?", id).Scan(&r.Workspace, &r.AllowTools, &paths, &input, &output, &r.RetryOf, &r.TitleSource, &r.TitleModel); err != nil { return nil, err } if err := decodeValues(input, &r.Input); err != nil { diff --git a/internal/pipeline/runs_test.go b/internal/pipeline/runs_test.go index ec165034..5edb8e70 100644 --- a/internal/pipeline/runs_test.go +++ b/internal/pipeline/runs_test.go @@ -5,7 +5,10 @@ import ( "fmt" "path/filepath" "reflect" + "strings" "testing" + + "git.a-wan.net/alan/pipelines/internal/summarise" ) func TestRunListIncludesHistoryBeyondFiftyForSearchAndPipelineScope(t *testing.T) { @@ -37,6 +40,126 @@ func TestRunListIncludesHistoryBeyondFiftyForSearchAndPipelineScope(t *testing.T } } +// TestRunTitleStorageMigrationAndFallback proves the three title contracts: an +// explicit title is kept verbatim, an absent one is derived bounded and +// non-empty, and runs created before the title columns survive the migration and +// still list. +func TestRunTitleStorageMigrationAndFallback(t *testing.T) { + ctx := context.Background() + path := filepath.Join(t.TempDir(), "titles.db") + store, err := Open(path) + if err != nil { + t.Fatal(err) + } + if _, err := store.Submit(ctx, "titled", Template([]string{"one"}, true)); err != nil { + t.Fatal(err) + } + items, _ := store.List(ctx) + definition, _ := store.Get(ctx, items[0].ID, 1) + + explicit, _, err := store.CreateRunTitled(ctx, definition, "explicit", "workspace", false, nil, + map[string]any{"prompt": "a prompt that must not become the title"}, + summarise.Title{Text: "Fix the flaky login test", Source: summarise.SourceModel, Model: "openai/gpt"}) + if err != nil { + t.Fatal(err) + } + got, err := store.GetRun(ctx, explicit) + if err != nil { + t.Fatal(err) + } + if got.Title != "Fix the flaky login test" || got.TitleSource != summarise.SourceModel || got.TitleModel != "openai/gpt" { + t.Fatalf("explicit title not kept verbatim with its provenance: %+v", got) + } + + derived, _, err := store.CreateRun(ctx, definition, "derived", "workspace", false, nil, + map[string]any{"prompt": strings.Repeat("é", 500) + "\nsecond line is ignored"}) + if err != nil { + t.Fatal(err) + } + got, err = store.GetRun(ctx, derived) + if err != nil { + t.Fatal(err) + } + if got.Title == "" || got.TitleSource != summarise.SourceFallback || got.TitleModel != "" { + t.Fatalf("derived title = %+v, want a non-empty fallback with no model", got) + } + if len([]rune(got.Title)) > summarise.TitleCap { + t.Fatalf("derived title has %d runes, want <= %d", len([]rune(got.Title)), summarise.TitleCap) + } + + // Simulate a database created before run titles by removing the columns, then + // reopen: existing rows must survive the re-add migration and still list. + for _, column := range []string{"title", "title_source", "title_model"} { + if _, err := store.db.ExecContext(ctx, "ALTER TABLE pipeline_runs DROP COLUMN "+column); err != nil { + t.Fatal(err) + } + } + if err := store.Close(); err != nil { + t.Fatal(err) + } + store, err = Open(path) + if err != nil { + t.Fatal(err) + } + defer store.Close() + runs, err := store.ListRuns(ctx) + if err != nil { + t.Fatal("legacy runs did not survive the title migration", err) + } + ids := map[int64]bool{} + for _, run := range runs { + ids[run.ID] = true + } + if !ids[explicit] || !ids[derived] { + t.Fatalf("migrated run list lost history: %+v", runs) + } + migrated, err := store.GetRun(ctx, explicit) + if err != nil || migrated.Title != "" || migrated.TitleSource != "" || migrated.TitleModel != "" { + t.Fatalf("migrated row should keep a valid empty title: %+v %v", migrated, err) + } +} + +// TestSetRunTitleRenamesWithoutTouchingInput proves an after-the-fact rename +// replaces the stored title and its provenance and leaves the run's input, +// status and steps untouched; an unknown run is reported, not silently ignored. +func TestSetRunTitleRenamesWithoutTouchingInput(t *testing.T) { + ctx := context.Background() + store, err := Open(filepath.Join(t.TempDir(), "rename.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + if _, err := store.Submit(ctx, "rename", Template([]string{"one"}, true)); err != nil { + t.Fatal(err) + } + items, _ := store.List(ctx) + definition, _ := store.Get(ctx, items[0].ID, 1) + id, _, err := store.CreateRun(ctx, definition, "rename-key", "workspace", false, nil, map[string]any{"prompt": "original derived prompt"}) + if err != nil { + t.Fatal(err) + } + before, err := store.GetRun(ctx, id) + if err != nil { + t.Fatal(err) + } + if err := store.SetRunTitle(ctx, id, summarise.Title{Text: "Investigate the regression", Source: summarise.SourceExplicit}); err != nil { + t.Fatal(err) + } + after, err := store.GetRun(ctx, id) + if err != nil { + t.Fatal(err) + } + if after.Title != "Investigate the regression" || after.TitleSource != summarise.SourceExplicit || after.TitleModel != "" { + t.Fatalf("rename = %+v, want the explicit title and provenance", after) + } + if after.Status != before.Status || !reflect.DeepEqual(after.Input, before.Input) || len(after.Steps) != len(before.Steps) { + t.Fatalf("rename changed run state: before %+v after %+v", before, after) + } + if err := store.SetRunTitle(ctx, id+999, summarise.Title{Text: "ghost", Source: summarise.SourceExplicit}); err == nil { + t.Fatal("renaming an unknown run succeeded") + } +} + func TestRunRecoveryAndVersionPinning(t *testing.T) { ctx := context.Background() path := filepath.Join(t.TempDir(), "audit.db") diff --git a/internal/protocol/message.go b/internal/protocol/message.go index 7b63b470..567eb8c1 100644 --- a/internal/protocol/message.go +++ b/internal/protocol/message.go @@ -121,6 +121,7 @@ type Message struct { Error string `json:"error,omitempty"` Name string `json:"name,omitempty"` Source string `json:"source,omitempty"` + Title string `json:"title,omitempty"` Version int `json:"version,omitempty"` Pipelines []PipelineSummary `json:"pipelines,omitempty"` PipelineID int64 `json:"pipeline_id,omitempty"` diff --git a/internal/protocol/runs.go b/internal/protocol/runs.go index dc4c0880..1ef5adc5 100644 --- a/internal/protocol/runs.go +++ b/internal/protocol/runs.go @@ -1,5 +1,7 @@ package protocol +import "strings" + const ( RunPipeline = "run_pipeline" RunStarted = "run_started" @@ -9,6 +11,7 @@ const ( Run = "run" CancelRun = "cancel_run" RetryRun = "retry_run" + SetRunTitle = "set_run_title" GetRunEvidence = "get_run_evidence" RunEvidence = "run_evidence" ) @@ -23,15 +26,20 @@ type SessionEvidence struct { } type RunSummary struct { - ID int64 `json:"id"` - PipelineID int64 `json:"pipeline_id"` - Name string `json:"name"` + ID int64 `json:"id"` + PipelineID int64 `json:"pipeline_id"` + Name string `json:"name"` + // Title is the operator-facing, bounded single-line description of what the + // run is for, generated from its prompt. It is never empty for a new run; + // historical rows predating the title column may omit it. + Title string `json:"title,omitempty"` Version int `json:"version"` ContentHash string `json:"content_hash"` Status string `json:"status"` Executing bool `json:"executing"` Outcome string `json:"outcome"` CurrentStage string `json:"current_stage"` + Workspace string `json:"workspace,omitempty"` CreatedAt string `json:"created_at"` FinishedAt string `json:"finished_at"` Diagnostic string `json:"diagnostic"` @@ -39,6 +47,16 @@ type RunSummary struct { CompletedSteps int `json:"completed_steps"` } +// Label is the operator-facing name of a run: the generated Title when the +// server stored one, otherwise the pipeline Name (historical rows predate +// titles). It is the single definition shared by the CLI and TUI. +func (r RunSummary) Label() string { + if title := strings.TrimSpace(r.Title); title != "" { + return title + } + return r.Name +} + type RunStep struct { Control *ControlEvidence `json:"control,omitempty"` FileChanges *StageFileChanges `json:"file_changes,omitempty"` @@ -126,4 +144,10 @@ type RunDetail struct { Input map[string]any `json:"input"` Output map[string]any `json:"output"` Steps []RunStep `json:"steps"` + // TitleSource is "model" when Title came from the shared summariser or + // "fallback" when it was derived from the prompt; TitleModel names the model + // that produced a model title. They are retained so a diagnosis can tell the + // two apart and see which model was used. + TitleSource string `json:"title_source,omitempty"` + TitleModel string `json:"title_model,omitempty"` } diff --git a/internal/server/cli_test.go b/internal/server/cli_test.go index be541b4f..ad082ff1 100644 --- a/internal/server/cli_test.go +++ b/internal/server/cli_test.go @@ -11,6 +11,7 @@ import ( "git.a-wan.net/alan/pipelines/internal/protocol" "git.a-wan.net/alan/pipelines/internal/runinspect" "git.a-wan.net/alan/pipelines/internal/stage" + "git.a-wan.net/alan/pipelines/internal/summarise" "net/http/httptest" "os" "path/filepath" @@ -143,3 +144,104 @@ func TestCLIHeadlessRunInspectionCancellationAndRPC(t *testing.T) { t.Fatal("wait lost terminal state", output) } } + +// TestCLIRunTitlesExplicitDerivedAndRename is the end-to-end title check: it +// drives the real CLI against the real websocket server and store, starts one +// run with --title and one without, and verifies the title is visible in the +// human `runs` list, in `inspect`, and after a `title` rename. Stage execution is +// stubbed because the environment must not call a model, so the without-flag run +// exercises the server-side prompt fallback rather than the shared summariser. +func TestCLIRunTitlesExplicitDerivedAndRename(t *testing.T) { + t.Setenv("PIPELINES_HARNESS_CONFIG", filepath.Join(t.TempDir(), "harnesses.json")) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + store, err := pipeline.Open(filepath.Join(t.TempDir(), "cli-titles.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + if _, err := store.Submit(ctx, "workflow", pipeline.Template([]string{"worker"}, true)); err != nil { + t.Fatal(err) + } + handler := Handler(ctx, store) + r := handler.(*runHandler).runner + r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { + return stage.Result{Outcome: "success", Output: stage.Values{"summary": "done"}}, nil + } + http := httptest.NewServer(handler) + defer http.Close() + defer func() { cancel(); WaitRuns(handler) }() + url := "ws" + strings.TrimPrefix(http.URL, "http") + "/connect" + run := func(args ...string) (string, error) { + var out bytes.Buffer + app := cli.App{Out: &out, Err: &out, In: strings.NewReader("")} + err := app.Run(ctx, append([]string{"--url", url}, args...)) + return out.String(), err + } + + output, err := run("run", "workflow", "first prompt line\nmore detail", "--title", "Operator chosen title", "--yes", "--json", "--wait") + if err != nil { + t.Fatal(err) + } + var started protocol.Message + if err := json.Unmarshal([]byte(output), &started); err != nil { + t.Fatal(err) + } + explicitID := started.RunDetail.ID + if started.RunDetail.Title != "Operator chosen title" || started.RunDetail.TitleSource != summarise.SourceExplicit { + t.Fatalf("explicit --title = %+v", started.RunDetail) + } + + output, err = run("run", "workflow", "Derived title from prompt\nsecond line", "--yes", "--json", "--wait") + if err != nil { + t.Fatal(err) + } + if err := json.Unmarshal([]byte(output), &started); err != nil { + t.Fatal(err) + } + if started.RunDetail.Title != "Derived title from prompt" || started.RunDetail.TitleSource != summarise.SourceFallback { + t.Fatalf("derived title = %+v", started.RunDetail) + } + + output, err = run("runs") + if err != nil { + t.Fatal(err) + } + t.Logf("pipelines runs:\n%s", output) + for _, want := range []string{ + fmt.Sprintf("%d\t%s\t%s\tv1\t%s\n", explicitID, "Operator chosen title", "workflow", "succeeded"), + fmt.Sprintf("%d\t%s\t%s\tv1\t%s\n", started.RunDetail.ID, "Derived title from prompt", "workflow", "succeeded"), + } { + if !strings.Contains(output, want) { + t.Fatalf("runs output missing %q:\n%s", want, output) + } + } + + output, err = run("inspect", fmt.Sprint(explicitID), "--json") + if err != nil { + t.Fatal(err) + } + var detail protocol.RunDetail + if err := json.Unmarshal([]byte(output), &detail); err != nil { + t.Fatal(err) + } + if detail.Title != "Operator chosen title" || detail.Name != "workflow" || detail.Version != 1 { + t.Fatalf("inspect omitted title/name/version: %+v", detail) + } + + output, err = run("title", fmt.Sprint(explicitID), "Renamed after the fact") + if err != nil { + t.Fatal(err) + } + t.Logf("pipelines title: %s", strings.TrimSpace(output)) + output, err = run("inspect", fmt.Sprint(explicitID), "--json") + if err != nil { + t.Fatal(err) + } + if err := json.Unmarshal([]byte(output), &detail); err != nil { + t.Fatal(err) + } + if detail.Title != "Renamed after the fact" || detail.TitleSource != summarise.SourceExplicit { + t.Fatalf("rename not visible in inspect: %+v", detail) + } +} diff --git a/internal/server/runner.go b/internal/server/runner.go index 9977dd36..af3bb3dc 100644 --- a/internal/server/runner.go +++ b/internal/server/runner.go @@ -18,6 +18,7 @@ import ( "git.a-wan.net/alan/pipelines/internal/pipeline" "git.a-wan.net/alan/pipelines/internal/protocol" "git.a-wan.net/alan/pipelines/internal/stage" + "git.a-wan.net/alan/pipelines/internal/summarise" ) // activeRun records one in-flight run's cancellation seam and the resolved @@ -35,8 +36,12 @@ type runner struct { mu sync.Mutex active map[int64]activeRun execute func(context.Context, stage.Definition, stage.Values) (stage.Result, error) - wg sync.WaitGroup - schedulerWG sync.WaitGroup + // title generates the operator-facing run title from the run prompt. When nil + // the store derives a fallback from the prompt with no model call, so tests + // and unconfigured servers stay deterministic. + title func(context.Context, string) summarise.Title + wg sync.WaitGroup + schedulerWG sync.WaitGroup } func newRunner(ctx context.Context, s *pipeline.Store) (*runner, error) { @@ -158,13 +163,19 @@ func (r *runner) start(request protocol.Message, retryOf ...int64) (*protocol.Ru } } } + // Decide admission and idempotency under the lock, but generate the title + // only for a request that will actually start a run: a rejected or replayed + // request must not pay for a bounded model generation, and a live one must + // not hold the lock (stalling listings and cancellation) while a model is + // called. An unavailable or slow model falls back to the prompt's first line. r.mu.Lock() - defer r.mu.Unlock() if r.ctx.Err() != nil { + r.mu.Unlock() return nil, r.ctx.Err() } owners, err := r.store.ActiveSessionOwners(r.ctx) if err != nil { + r.mu.Unlock() return nil, err } // Refuse only an orphaned session: one whose owning run is not active now. @@ -172,28 +183,49 @@ func (r *runner) start(request protocol.Message, retryOf ...int64) (*protocol.Ru // workspace) must not block new work. for _, owner := range owners { if _, ok := r.active[owner.RunID]; !ok { + r.mu.Unlock() return nil, fmt.Errorf("an agent may still be active; restart recovery must interrupt it before new work") } } - // Idempotent repeats are accepted even while the original run is active. - if len(r.active) > 0 { - existing, err := r.store.RunByKey(r.ctx, request.RequestKey) - if err != nil { + // Idempotent repeats are accepted even while the original run is active, and + // a replay reuses the stored title instead of generating a new one. + existing, err := r.store.RunByKey(r.ctx, request.RequestKey) + if err != nil { + r.mu.Unlock() + return nil, err + } + if existing == 0 { + if err := r.checkWorkspaceFree(workspace); err != nil { + r.mu.Unlock() return nil, err } - if existing == 0 { - // The workspace is the only scope a run reserves: refuse a second - // run only when an active run is already changing this exact - // resolved directory. One active run per workspace keeps this scan - // finding at most one match, so the message is deterministic. - for id, entry := range r.active { - if entry.workspace == workspace { - return nil, fmt.Errorf("run %d is already active in workspace %s; wait for it to finish or start this run in a different workspace (for example another checkout of the repository)", id, workspace) - } - } + } + r.mu.Unlock() + + var runTitle summarise.Title + if existing == 0 { + // An explicit operator title skips the model call; otherwise the + // configured generator names the run, falling back to the prompt's + // first line when it is unavailable or slow. + if explicit, ok := summarise.ExplicitTitle(request.Title); ok { + runTitle = explicit + } else if r.title != nil { + prompt, _ := request.Input["prompt"].(string) + runTitle = r.title(r.ctx, prompt) } } - id, created, err := r.store.CreateRun(r.ctx, d, request.RequestKey, workspace, request.AllowTools, request.WritePaths, request.Input, retryOf...) + + r.mu.Lock() + defer r.mu.Unlock() + // Another run may have reserved this workspace while the title was + // generated, so re-check before reserving it; a race on the request key is + // handled by the store's idempotent insert. + if existing == 0 { + if err := r.checkWorkspaceFree(workspace); err != nil { + return nil, err + } + } + id, created, err := r.store.CreateRunTitled(r.ctx, d, request.RequestKey, workspace, request.AllowTools, request.WritePaths, request.Input, runTitle, retryOf...) if err != nil { return nil, err } @@ -215,6 +247,19 @@ func (r *runner) start(request protocol.Message, retryOf ...int64) (*protocol.Ru return detail, err } +// checkWorkspaceFree refuses a run when an active run is already changing the +// same resolved workspace. The workspace is the only scope a run reserves, and +// one active run per workspace keeps this scan finding at most one match, so the +// message is deterministic. Callers must hold r.mu. +func (r *runner) checkWorkspaceFree(workspace string) error { + for id, entry := range r.active { + if entry.workspace == workspace { + return fmt.Errorf("run %d is already active in workspace %s; wait for it to finish or start this run in a different workspace (for example another checkout of the repository)", id, workspace) + } + } + return nil +} + func (r *runner) getRun(id int64) (*protocol.RunDetail, error) { r.mu.Lock() defer r.mu.Unlock() @@ -279,6 +324,19 @@ func (r *runner) cancel(id int64) error { return nil } +// setTitle renames a run: it replaces the stored operator-facing title without +// touching the run's input, steps or execution, then returns the updated detail. +func (r *runner) setTitle(id int64, title string) (*protocol.RunDetail, error) { + explicit, ok := summarise.ExplicitTitle(title) + if !ok { + return nil, fmt.Errorf("a title with usable text is required") + } + if err := r.store.SetRunTitle(r.ctx, id, explicit); err != nil { + return nil, err + } + return r.getRun(id) +} + func (r *runner) run(ctx context.Context, id int64, d *protocol.PipelineDetail, workspace string, request protocol.Message) { input := stage.Values(request.Input) key := d.Graph.Stages[0].Key diff --git a/internal/server/runner_test.go b/internal/server/runner_test.go index 2da8d9fe..3417078a 100644 --- a/internal/server/runner_test.go +++ b/internal/server/runner_test.go @@ -11,8 +11,194 @@ import ( "git.a-wan.net/alan/pipelines/internal/pipeline" "git.a-wan.net/alan/pipelines/internal/protocol" "git.a-wan.net/alan/pipelines/internal/stage" + "git.a-wan.net/alan/pipelines/internal/summarise" ) +// TestRunTitleGeneratedPersistedAndFallback proves the insert path stores a +// generated title with its provenance in list and detail responses, and falls +// back to a derived bounded title when no generator is wired, without failing +// run creation. +func TestRunTitleGeneratedPersistedAndFallback(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + store, err := pipeline.Open(filepath.Join(t.TempDir(), "titles.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + if _, err := store.Submit(ctx, "titled", pipeline.Template([]string{"one"}, true)); err != nil { + t.Fatal(err) + } + items, _ := store.List(ctx) + r, err := newRunner(ctx, store) + if err != nil { + t.Fatal(err) + } + r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { + return stage.Result{Outcome: "success", Output: stage.Values{}}, nil + } + r.title = func(context.Context, string) summarise.Title { + return summarise.Title{Text: "Fix the flaky login test", Source: summarise.SourceModel, Model: "openai/gpt"} + } + run, err := r.start(protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "model-title", Workspace: t.TempDir(), Input: map[string]any{"prompt": "prompt body"}}) + if err != nil { + t.Fatal(err) + } + r.wg.Wait() + detail, err := store.GetRun(ctx, run.ID) + if err != nil { + t.Fatal(err) + } + if detail.Title != "Fix the flaky login test" || detail.TitleSource != summarise.SourceModel || detail.TitleModel != "openai/gpt" { + t.Fatalf("model title not stored with provenance: %+v", detail) + } + list, err := store.ListRuns(ctx) + if err != nil || len(list) != 1 || list[0].Title != "Fix the flaky login test" { + t.Fatalf("run list omitted the title: %v %v", list, err) + } + + // No generator: the fallback is derived from the prompt's first line and run + // creation still succeeds. + r.title = nil + fallback, err := r.start(protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "fallback-title", Workspace: t.TempDir(), Input: map[string]any{"prompt": "Fix the widget\nand more detail"}}) + if err != nil { + t.Fatal(err) + } + r.wg.Wait() + detail, err = store.GetRun(ctx, fallback.ID) + if err != nil { + t.Fatal(err) + } + if detail.Title != "Fix the widget" || detail.TitleSource != summarise.SourceFallback || detail.TitleModel != "" { + t.Fatalf("fallback title = %+v, want the prompt's first line", detail) + } +} + +// TestRunTitleGeneratorSkippedForReplayAndRejection proves the bounded +// generation runs only for a request that starts a run: an idempotent replay and +// a request refused for an already-reserved workspace must not pay for it. +func TestRunTitleGeneratorSkippedForReplayAndRejection(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + store, err := pipeline.Open(filepath.Join(t.TempDir(), "skip.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + if _, err := store.Submit(ctx, "skip", pipeline.Template([]string{"one"}, true)); err != nil { + t.Fatal(err) + } + items, _ := store.List(ctx) + r, err := newRunner(ctx, store) + if err != nil { + t.Fatal(err) + } + release := make(chan struct{}) + r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { + <-release + return stage.Result{Outcome: "success", Output: stage.Values{}}, nil + } + calls := 0 + r.title = func(context.Context, string) summarise.Title { + calls++ + return summarise.Title{Text: "Generated", Source: summarise.SourceModel} + } + workspace := t.TempDir() + first, err := r.start(protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "skip-key", Workspace: workspace, Input: map[string]any{"prompt": "first"}}) + if err != nil { + t.Fatal(err) + } + if calls != 1 { + t.Fatalf("first start generated %d titles, want 1", calls) + } + // A replay while the first run is active reuses the stored title. + replay, err := r.start(protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "skip-key", Workspace: workspace, Input: map[string]any{"prompt": "first"}}) + if err != nil || replay.ID != first.ID { + t.Fatalf("replay = %+v, %v; want run %d", replay, err, first.ID) + } + // A new key in the already-reserved workspace is refused. + if _, err := r.start(protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "skip-other", Workspace: workspace, Input: map[string]any{"prompt": "second"}}); err == nil { + t.Fatal("workspace conflict was not refused") + } + if calls != 1 { + t.Fatalf("replay/rejection generated %d titles, want 1", calls) + } + close(release) + r.wg.Wait() +} + +func TestHandlerWiresRunTitleGenerator(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + store, err := pipeline.Open(filepath.Join(t.TempDir(), "wire.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + configured := HandlerWithOptions(ctx, Options{RunTitles: summarise.GenerateTitle}, store).(*runHandler) + bare := HandlerWithOptions(ctx, Options{}, store).(*runHandler) + defer func() { cancel(); WaitRuns(configured); WaitRuns(bare) }() + if configured.runner.title == nil { + t.Fatal("configured RunTitles was not applied to the runner") + } + if bare.runner.title != nil { + t.Fatal("unconfigured RunTitles must keep deterministic fallback title generation") + } +} + +// TestRunnerExplicitTitleSkipsGeneratorAndRenames proves an explicit --title is +// stored verbatim and skips the model generator, and that setTitle later +// replaces it with an explicit provenance without touching the run's input. +func TestRunnerExplicitTitleSkipsGeneratorAndRenames(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + store, err := pipeline.Open(filepath.Join(t.TempDir(), "explicit.db")) + if err != nil { + t.Fatal(err) + } + defer store.Close() + if _, err := store.Submit(ctx, "explicit", pipeline.Template([]string{"one"}, true)); err != nil { + t.Fatal(err) + } + items, _ := store.List(ctx) + r, err := newRunner(ctx, store) + if err != nil { + t.Fatal(err) + } + r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { + return stage.Result{Outcome: "success", Output: stage.Values{}}, nil + } + generated := 0 + r.title = func(context.Context, string) summarise.Title { + generated++ + return summarise.Title{Text: "Generated", Source: summarise.SourceModel} + } + run, err := r.start(protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "explicit-key", Workspace: t.TempDir(), Title: "Operator chosen title", Input: map[string]any{"prompt": "prompt body"}}) + if err != nil { + t.Fatal(err) + } + r.wg.Wait() + if generated != 0 { + t.Fatalf("explicit title still called the generator %d times", generated) + } + if run.Title != "Operator chosen title" || run.TitleSource != summarise.SourceExplicit || run.TitleModel != "" { + t.Fatalf("explicit title = %+v", run) + } + + renamed, err := r.setTitle(run.ID, " Renamed after the fact ") + if err != nil { + t.Fatal(err) + } + if renamed.Title != "Renamed after the fact" || renamed.TitleSource != summarise.SourceExplicit || renamed.Input["prompt"] != "prompt body" { + t.Fatalf("rename = %+v", renamed) + } + if _, err := r.setTitle(run.ID, " "); err == nil { + t.Fatal("blank rename was accepted") + } + if _, err := r.setTitle(run.ID+999, "ghost"); err == nil { + t.Fatal("renaming an unknown run was accepted") + } +} + func TestRunnerRoutingPersistenceAndIdempotency(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() diff --git a/internal/server/websocket.go b/internal/server/websocket.go index e311d376..31c8c4dd 100644 --- a/internal/server/websocket.go +++ b/internal/server/websocket.go @@ -15,6 +15,7 @@ import ( "git.a-wan.net/alan/pipelines/internal/buildinfo" "git.a-wan.net/alan/pipelines/internal/pipeline" "git.a-wan.net/alan/pipelines/internal/protocol" + "git.a-wan.net/alan/pipelines/internal/summarise" ) // Options configures the HTTP handler. @@ -31,6 +32,10 @@ type Options struct { // it from the first store; when neither is available chat_sessions returns an // empty list rather than the endpoint's whole session list. OwnedSessions func(context.Context) ([]pipeline.SessionOwner, error) + // RunTitles generates the operator-facing title stored with each new run. + // When nil, run creation stores the prompt-derived fallback without a model + // call, which keeps tests and unconfigured servers deterministic. + RunTitles func(context.Context, string) summarise.Title } // Handler serves the persistent connection with default options. Canceling ctx @@ -53,6 +58,9 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin if runErr == nil && options.ArtifactsRoot != "" { runs.artifactsRoot = options.ArtifactsRoot } + if runErr == nil && options.RunTitles != nil { + runs.title = options.RunTitles + } if runErr == nil { runs.schedulerWG.Add(1) go runs.scheduleLoop() @@ -192,7 +200,7 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin } else { response.Pipelines = items } - } else if runs != nil && (request.Type == protocol.RunPipeline || request.Type == protocol.RetryRun || request.Type == protocol.ListRuns || request.Type == protocol.GetRun || request.Type == protocol.CancelRun || request.Type == protocol.GetRunEvidence) { + } else if runs != nil && (request.Type == protocol.RunPipeline || request.Type == protocol.RetryRun || request.Type == protocol.ListRuns || request.Type == protocol.GetRun || request.Type == protocol.CancelRun || request.Type == protocol.SetRunTitle || request.Type == protocol.GetRunEvidence) { var err error switch request.Type { case protocol.GetRunEvidence: @@ -204,6 +212,9 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin case protocol.RetryRun: response.Type = protocol.RunStarted response.RunDetail, err = runs.retry(request) + case protocol.SetRunTitle: + response.Type = protocol.Run + response.RunDetail, err = runs.setTitle(request.RunID, request.Title) case protocol.ListRuns: response.Type = protocol.Runs response.Runs, err = runs.listRuns() diff --git a/internal/summarise/summarise.go b/internal/summarise/summarise.go index dbb41ce7..95c473fb 100644 --- a/internal/summarise/summarise.go +++ b/internal/summarise/summarise.go @@ -9,10 +9,14 @@ // the NoSummary sentinel instead of failing, stalling or delaying a stage or a // run. It never runs tools, never writes files and never propagates an error. // -// Obvious future call sites (not wired here): protocol.OutputPreview in -// internal/protocol/result.go and the notification summary in -// internal/server/notify.go. Changing a user-visible title/verdict later also -// requires updating the relevant internal/author/skill/references/*.md. +// Title/GenerateTitle build on Summarise to give every run a bounded, never +// empty operator-facing title: the model line when it succeeds and the prompt's +// first line otherwise. The server wires GenerateTitle at run creation; the +// store persists it with its source/model provenance. Obvious future call sites +// (not wired here): protocol.OutputPreview in internal/protocol/result.go and the +// notification summary in internal/server/notify.go. Changing a user-visible +// title/verdict later also requires updating the relevant +// internal/author/skill/references/*.md. package summarise import ( @@ -42,6 +46,31 @@ const InputCap = 8 << 10 // are trimmed, never streamed onward. const OutputCap = 200 +// TitleCap bounds an operator-facing run title (in runes) whether it came from +// the model or the fallback, so a stored title stays a short single line. +const TitleCap = 80 + +// FallbackTitle is the last-resort title used when a prompt has no usable line, +// so a stored title is never empty. +const FallbackTitle = "Untitled run" + +// Title provenance recorded beside a stored run title so a diagnosis can tell a +// model title from the derived fallback. +const ( + SourceModel = "model" + SourceFallback = "fallback" + SourceExplicit = "explicit" +) + +// Title is a bounded, single-line operator-facing run title plus how it was +// produced: SourceModel with the generating Model, SourceFallback, or +// SourceExplicit when the operator typed it (--title or a rename). +type Title struct { + Text string + Source string + Model string +} + // DefaultTimeout is the hard per-call budget: one generation must finish within // a few seconds even when the caller passes a longer or absent deadline. const DefaultTimeout = 5 * time.Second @@ -59,6 +88,10 @@ const quoteCutset = "\"'`\u2018\u2019\u201c\u201d" // punctCutset is the set of trailing punctuation stripped from a summary line. const punctCutset = ".!?,;:\u2026\u3002\uff01\uff1f\uff0c\uff1b\uff1a" +// markCutset is the set of leading markdown markers (headings, quotes, list and +// emphasis tokens) stripped from a cleaned line so a title carries no markdown. +const markCutset = "#>*_`-+" + // Selection is the resolved harness configuration the summariser generates with. // Harness, Executable and Model come from the configured default harness profile // (its interactive Model, never its PipelineModel); none of them are constants. @@ -105,20 +138,28 @@ type Summariser struct { // records at most one bounded OperationEvidence when a call fails and Operations // is configured. It never propagates an error and never runs tools. func (s Summariser) Summarise(ctx context.Context, source string) string { + line, _ := s.summarise(ctx, source) + return line +} + +// summarise is the single implementation behind Summarise and Title. It returns +// the bounded line (or NoSummary) and the resolved selection, so a caller can +// record which model produced it without resolving the harness twice. +func (s Summariser) summarise(ctx context.Context, source string) (string, Selection) { selection, err := s.resolve() if err != nil { s.log(Selection{}, true, err) - return NoSummary + return NoSummary, Selection{} } if strings.TrimSpace(source) == "" { s.log(selection, false, nil) - return NoSummary + return NoSummary, selection } generator, err := s.generator(selection) if err != nil { s.record(selection, err) s.log(selection, true, err) - return NoSummary + return NoSummary, selection } timeout := s.Timeout if timeout <= 0 { @@ -141,17 +182,62 @@ func (s Summariser) Summarise(ctx context.Context, source string) string { if err != nil { s.record(selection, err) s.log(selection, true, err) - return NoSummary + return NoSummary, selection } line := oneLine(text) if line == "" { err = fmt.Errorf("model returned no usable one-line summary") s.record(selection, err) s.log(selection, true, err) - return NoSummary + return NoSummary, selection } s.log(selection, false, nil) - return line + return line, selection +} + +// Title returns a bounded, single-line operator-facing title for a run created +// from prompt. It asks the shared summariser for one bounded line and, when that +// fails or times out, falls back to the prompt's first usable line. It never +// returns an empty title, never propagates an error and never exceeds the +// summariser's hard timeout, so run creation always starts with a usable title. +func (s Summariser) Title(ctx context.Context, prompt string) Title { + line, selection := s.summarise(ctx, prompt) + if line != NoSummary { + if text := capRunes(line, TitleCap); text != "" { + return Title{Text: text, Source: SourceModel, Model: selection.Model} + } + } + return Title{Text: DeriveTitle(prompt), Source: SourceFallback} +} + +// GenerateTitle is the package entry point that derives a run title from the +// configured default harness, so a caller need not construct a Summariser. It is +// bounded and never blocks past the summariser's hard timeout. +func GenerateTitle(ctx context.Context, prompt string) Title { return Summariser{}.Title(ctx, prompt) } + +// DeriveTitle is the bounded fallback title for a run prompt: its first usable +// line, cleaned the same way a model reply is and capped to TitleCap runes. It is +// never empty. +func DeriveTitle(prompt string) string { + for _, raw := range strings.Split(prompt, "\n") { + if line := cleanLine(raw); line != "" { + return capRunes(line, TitleCap) + } + } + return FallbackTitle +} + +// ExplicitTitle normalises an operator-supplied run title (--title or a rename) +// to a bounded single line and reports whether it carried usable text. Unlike a +// derived title it preserves the operator's wording and punctuation, only +// collapsing whitespace and controlling characters; it is never generated or +// model-cleaned. +func ExplicitTitle(raw string) (Title, bool) { + text := capRunes(protocol.NormalizeText(raw), TitleCap) + if text == "" { + return Title{}, false + } + return Title{Text: text, Source: SourceExplicit}, true } func (s Summariser) resolve() (Selection, error) { @@ -208,23 +294,31 @@ func truncateSource(source string) string { // punctuation, and caps the result to OutputCap runes. func oneLine(text string) string { for _, raw := range strings.Split(text, "\n") { - line := strings.TrimSpace(raw) - if line == "" || isFenceLine(line) { - continue + if line := cleanLine(raw); line != "" { + return capRunes(line, OutputCap) } - line = strings.TrimSpace(protocol.NormalizeText(line)) - line = strings.Trim(line, quoteCutset) - line = strings.TrimSpace(line) - line = strings.TrimRight(line, punctCutset) - line = strings.TrimSpace(line) - if line == "" { - continue - } - return capRunes(line, OutputCap) } return "" } +// cleanLine reduces one raw line to plain single-line text, or "" when it carries +// no usable content (empty, whitespace or a bare code fence). It collapses +// whitespace/control characters, strips surrounding quotes, leading markdown +// markers and trailing punctuation. It is the shared primitive behind a summary +// line and a derived run title. +func cleanLine(raw string) string { + line := strings.TrimSpace(raw) + if line == "" || isFenceLine(line) { + return "" + } + line = strings.TrimSpace(protocol.NormalizeText(line)) + line = strings.TrimSpace(strings.TrimLeft(line, markCutset)) + line = strings.Trim(line, quoteCutset) + line = strings.TrimSpace(line) + line = strings.TrimRight(line, punctCutset) + return strings.TrimSpace(line) +} + // isFenceLine reports whether a trimmed line is a markdown code-fence delimiter // (an optional language token after a run of backticks/tildes, but no content). // "```Summary```" is not a fence line: it carries content and is cleaned instead. diff --git a/internal/summarise/summarise_test.go b/internal/summarise/summarise_test.go index 08c77ada..931ed05b 100644 --- a/internal/summarise/summarise_test.go +++ b/internal/summarise/summarise_test.go @@ -267,6 +267,87 @@ func TestSummariseDiagnostics(t *testing.T) { } } +func TestTitleUsesModelLineAndRecordsSource(t *testing.T) { + s := Summariser{ + Selection: selection(), + Generator: generatorFunc(func(context.Context, stage.ModelConfig, string) (string, error) { + return `## "Fix the flaky login test."`, nil + }), + } + got := s.Title(context.Background(), "prompt text") + if got.Text != "Fix the flaky login test" { + t.Fatalf("got %q, want the cleaned model title", got.Text) + } + if got.Source != SourceModel || got.Model != "p/open" { + t.Fatalf("title provenance = %+v, want model p/open", got) + } +} + +func TestTitleFallsBackToBoundedPromptLine(t *testing.T) { + long := strings.Repeat("é", TitleCap*2) + s := Summariser{ + Selection: selection(), + Generator: generatorFunc(func(context.Context, stage.ModelConfig, string) (string, error) { + return "", errors.New("transport down") + }), + } + for _, prompt := range []string{"First line\nthen ignored", " \n Fix the widget \nmore", "- bullet task here\nrest", long} { + got := s.Title(context.Background(), prompt) + if got.Text == "" || got.Text == NoSummary || got.Text == FallbackTitle { + t.Fatalf("prompt %q produced unusable title %+v", prompt, got) + } + if got.Source != SourceFallback || got.Model != "" { + t.Fatalf("prompt %q provenance = %+v, want fallback with no model", prompt, got) + } + if len([]rune(got.Text)) > TitleCap { + t.Fatalf("prompt %q title has %d runes, want <= %d", prompt, len([]rune(got.Text)), TitleCap) + } + if strings.ContainsAny(got.Text, "\r\n") { + t.Fatalf("prompt %q title %q is not a single line", prompt, got.Text) + } + } + if got := s.Title(context.Background(), "First line\nthen ignored"); got.Text != "First line" { + t.Fatalf("fallback title = %q, want the prompt's first line", got.Text) + } + if got := s.Title(context.Background(), "- bullet task here\nrest"); got.Text != "bullet task here" { + t.Fatalf("fallback stripped markdown = %q, want the leading marker removed", got.Text) + } +} + +func TestTitleNeverEmptyForBlankPrompt(t *testing.T) { + s := Summariser{ + Selection: selection(), + Generator: generatorFunc(func(context.Context, stage.ModelConfig, string) (string, error) { + return "", nil + }), + } + got := s.Title(context.Background(), " \n\t") + if got.Text != FallbackTitle || got.Source != SourceFallback { + t.Fatalf("blank prompt title = %+v, want %q fallback", got, FallbackTitle) + } +} + +func TestExplicitTitleNormalisesAndBounds(t *testing.T) { + got, ok := ExplicitTitle(" Fix the\nflaky login test ") + if !ok || got.Text != "Fix the flaky login test" || got.Source != SourceExplicit || got.Model != "" { + t.Fatalf("explicit title = %+v, %t; want collapsed explicit text", got, ok) + } + // The operator's punctuation and wording are preserved, unlike a cleaned + // model line. + if got, ok := ExplicitTitle("Ship v2.0!"); !ok || got.Text != "Ship v2.0!" { + t.Fatalf("explicit title altered the operator's text: %+v %t", got, ok) + } + long := strings.Repeat("é", TitleCap*2) + if got, ok := ExplicitTitle(long); !ok || len([]rune(got.Text)) != TitleCap { + t.Fatalf("explicit title not capped to %d runes: %d", TitleCap, len([]rune(got.Text))) + } + for _, blank := range []string{"", " ", "\n\t", "\x00\x01"} { + if got, ok := ExplicitTitle(blank); ok { + t.Fatalf("blank explicit title %q accepted as %+v", blank, got) + } + } +} + func TestSummariseSuccessLogsAndRecordsNoFailure(t *testing.T) { var logs []string operations := &stage.OperationLog{} diff --git a/internal/tui/cli_run.go b/internal/tui/cli_run.go index 674991f0..f805da4e 100644 --- a/internal/tui/cli_run.go +++ b/internal/tui/cli_run.go @@ -10,9 +10,9 @@ import ( ) type RunOptions struct { - Pipeline, Prompt, Workspace string - Yes, AllowTools bool - WritePaths []string + Pipeline, Prompt, Title, Workspace string + Yes, AllowTools bool + WritePaths []string } func NewRun(ctx context.Context, url string, options RunOptions) Model { diff --git a/internal/tui/dashboard.go b/internal/tui/dashboard.go index 22f5fd4d..c7f02b48 100644 --- a/internal/tui/dashboard.go +++ b/internal/tui/dashboard.go @@ -98,7 +98,7 @@ func (m Model) homeLines() []string { limit = 2 } for _, r := range m.runs[:min(limit, len(m.runs))] { - runs = append(runs, bar(fmt.Sprintf("#%d %s", r.ID, r.Name), m.progress(r.Status), max(1, panelWidth-4), false)) + runs = append(runs, bar(fmt.Sprintf("#%d %s", r.ID, r.Label()), m.progress(r.Status), max(1, panelWidth-4), false)) runs = append(runs, previewRows(resultLabel(r), max(1, panelWidth-4), 3)...) runs = append(runs, lipgloss.NewStyle().Foreground(themeMuted).Render(fmt.Sprintf("v%d · %d completed visits · %s", r.Version, r.CompletedSteps, runDuration(r.CreatedAt, r.FinishedAt)))) if r.CurrentStage != "" && (r.Status == "running" || r.Status == "queued") { @@ -123,7 +123,7 @@ func (m Model) homeLines() []string { lines = append(lines, lipgloss.NewStyle().Bold(true).Render(p.Name), lipgloss.NewStyle().Foreground(themeMuted).Render(fmt.Sprintf("v%d · %d stages", p.Version, p.Stages))) if r := m.latestPipelineRun(p.ID, 0); r != nil { - lines = append(lines, fmt.Sprintf("Last run #%d · v%d · %s", r.ID, r.Version, m.progress(r.Status))) + lines = append(lines, fmt.Sprintf("Last run #%d · %s · v%d · %s", r.ID, r.Label(), r.Version, m.progress(r.Status))) lines = append(lines, previewRows(resultLabel(*r), max(1, pipelineWidth-4), 2)...) } else { lines = append(lines, "Not run yet · no recorded results") diff --git a/internal/tui/results.go b/internal/tui/results.go index 1cc7bdf7..c5f57fcd 100644 --- a/internal/tui/results.go +++ b/internal/tui/results.go @@ -48,7 +48,7 @@ func (m Model) pipelineResultLines() []string { if r == nil { return []string{"Results · This version has not run yet. No accomplishments recorded."} } - lines := []string{fmt.Sprintf("Results · run #%d · %s · %d completed visits · %s", r.ID, ansi.Strip(m.progress(r.Status)), r.CompletedSteps, runDuration(r.CreatedAt, r.FinishedAt)), resultLabel(*r)} + lines := []string{fmt.Sprintf("Results · run #%d · %s · %s · %d completed visits · %s", r.ID, r.Label(), ansi.Strip(m.progress(r.Status)), r.CompletedSteps, runDuration(r.CreatedAt, r.FinishedAt)), resultLabel(*r)} if r.Status != "succeeded" && r.ResultPreview != "" && r.Diagnostic != "" { lines = append(lines, "Partial output: "+ansi.Strip(r.ResultPreview)) } diff --git a/internal/tui/run_detail.go b/internal/tui/run_detail.go index 103bf141..9e7fd90f 100644 --- a/internal/tui/run_detail.go +++ b/internal/tui/run_detail.go @@ -126,7 +126,7 @@ func (m Model) visibleRuns() []protocol.RunSummary { } labels := make([]string, len(runs)) for i, run := range runs { - labels[i] = fmt.Sprintf("#%d %s v%d %s %s %s %s", run.ID, run.Name, run.Version, run.Status, run.Outcome, run.CurrentStage, run.Diagnostic) + labels[i] = fmt.Sprintf("#%d %s v%d %s %s %s %s", run.ID, run.Label(), run.Version, run.Status, run.Outcome, run.CurrentStage, run.Diagnostic) } matched := make([]protocol.RunSummary, 0) for _, match := range fuzzy.Find(query, labels) { @@ -589,7 +589,7 @@ func (m Model) runsDetailsView(height int) string { start, end := selectionWindow(len(runs), m.runIndex, max(1, (height-4-len(rows))/2)) for i := start; i < end; i++ { r := runs[i] - text := fmt.Sprintf("#%d %s · v%d · %s · %s", r.ID, r.Name, r.Version, m.progress(r.Status), dateLabel(r.FinishedAt)) + text := fmt.Sprintf("#%d %s · v%d · %s · %s", r.ID, r.Label(), r.Version, m.progress(r.Status), dateLabel(r.FinishedAt)) rows = append(rows, menuOption(text, i == m.runIndex)) rows = append(rows, " "+ansi.Truncate(resultLabel(r), max(1, m.width-6), "…")) } @@ -612,7 +612,7 @@ func (m Model) runsDetailsView(height int) string { return panel(m.width, height, []string{bar(title, fmt.Sprint(len(runs)), max(1, m.width-4), true)}, rows, footer, true) } r := m.runDetail - header := bar(fmt.Sprintf("#%d %s · v%d", r.ID, r.Name, r.Version), m.progress(r.Status)+" · "+runDuration(r.CreatedAt, r.FinishedAt), m.width, false) + header := bar(fmt.Sprintf("#%d %s · v%d", r.ID, r.Label(), r.Version), m.progress(r.Status)+" · "+runDuration(r.CreatedAt, r.FinishedAt), m.width, false) if height <= 6 { return fitBlock([]string{header, runHighlight(m.runSelectionLabel(), m.width), m.runActions() + " · Tab pane · Esc back"}, m.width, height) } diff --git a/internal/tui/runs.go b/internal/tui/runs.go index f61ad639..0aea25f4 100644 --- a/internal/tui/runs.go +++ b/internal/tui/runs.go @@ -147,7 +147,7 @@ func (m *Model) startSelectedRun() tea.Cmd { m.runCollapsed = nil m.runDetail = nil m.runTop = 0 - request := protocol.Message{Type: protocol.RunPipeline, PipelineID: m.detail.ID, Version: m.detail.Version, RequestKey: fmt.Sprintf("tui-%d", time.Now().UnixNano()), Input: initialRunInput(m.runTask), AllowTools: m.runHasMutationTools(), WritePaths: m.runPaths, Workspace: m.runWorkspace} + request := protocol.Message{Type: protocol.RunPipeline, PipelineID: m.detail.ID, Version: m.detail.Version, RequestKey: fmt.Sprintf("tui-%d", time.Now().UnixNano()), Title: m.cliOptions.Title, Input: initialRunInput(m.runTask), AllowTools: m.runHasMutationTools(), WritePaths: m.runPaths, Workspace: m.runWorkspace} updated, cmd := m.runRequest(request) *m = updated.(Model) return cmd diff --git a/internal/tui/runs_test.go b/internal/tui/runs_test.go index 3cf0b7ec..b60c3d61 100644 --- a/internal/tui/runs_test.go +++ b/internal/tui/runs_test.go @@ -43,6 +43,24 @@ func TestRunFormAndInspection(t *testing.T) { } } +func TestRunTitleIsShownToOperator(t *testing.T) { + titled := protocol.RunSummary{ID: 1, Name: "bug fix", Version: 2, Title: "Fix the flaky login test", Status: "succeeded"} + if got := titled.Label(); got != "Fix the flaky login test" { + t.Fatalf("Label = %q, want the generated title", got) + } + if got := (protocol.RunSummary{Name: "bug fix"}).Label(); got != "bug fix" { + t.Fatalf("Label without a title = %q, want the pipeline name fallback", got) + } + m := New(context.Background(), "") + m.width = 100 + m.height = 28 + m.runOpen = true + m.runDetail = &protocol.RunDetail{RunSummary: titled} + if view := ansi.Strip(m.runsDetailsView(24)); !strings.Contains(view, "Fix the flaky login test") { + t.Fatalf("run detail header omitted the title:\n%s", view) + } +} + func runInspectionModel() Model { m := New(context.Background(), "") m.width = 100