diff --git a/.claude/skills/changelog/watermark b/.claude/skills/changelog/watermark index 650d2399c..6707ae261 100644 --- a/.claude/skills/changelog/watermark +++ b/.claude/skills/changelog/watermark @@ -1 +1 @@ -118ce83966c849f2a2698f320291a6fee7071dbf +061ccc673b0409778edb759bb4fbdd1bee923247 diff --git a/docs/public/changelog/2026-04-30.mdx b/docs/public/changelog/2026-04-30.mdx index eb6893156..23613f5f9 100644 --- a/docs/public/changelog/2026-04-30.mdx +++ b/docs/public/changelog/2026-04-30.mdx @@ -1,5 +1,5 @@ --- -title: "Precise stage outcomes" +title: "Command logs and precise stage outcomes" date: "2026-04-30" --- @@ -13,6 +13,18 @@ To migrate: 4. Remove `outcome=retry` branches and use retry policies plus `stage.retrying` events for retry observability. +## Live command output logs + +Command stages used to expose output mostly through event payloads and short diagnostic tails. Fabro now records stdout and stderr as per-stage logs while the command runs, stores the finalized streams in CAS-backed storage, and renders separate live output panels in the run stage view. + +API clients can tail the same logs by byte offset, which makes long-running scripts easier to follow without reloading an entire run projection: + +```bash +curl "$FABRO_SERVER/api/v1/runs/$RUN_ID/stages/$STAGE_ID/logs/stdout?offset=0" +``` + +The same command log data is available to edge routing and retros after the command finishes, so workflow decisions and run narratives can inspect the final output without relying on truncated event fields. + ## Precise stage outcomes Fabro now separates a stage's terminal outcome from its live execution state. Workflow routing sees four stable outcomes - `succeeded`, `failed`, `partially_succeeded`, and `skipped` - while retrying remains an internal execution state surfaced through events. @@ -34,6 +46,7 @@ The OpenAPI schema also reuses canonical billing, model, provider, settings, and ## More +- New `GET /api/v1/runs/{id}/stages/{stageId}/logs/{stream}` endpoint tails command stdout or stderr with byte offsets - Replaced the generated `StageStatus` model with `StageState` and `StageOutcome` shapes - Tightened shared model, billing, provider, and settings schemas in the OpenAPI contract - Added `configured` to `GET /models` responses so clients can tell whether credential material is present before testing a model @@ -43,4 +56,17 @@ The OpenAPI schema also reuses canonical billing, model, provider, settings, and - `allow_partial=true` now promotes exhausted retryable failures to `partially_succeeded` - Retryable failures emit retrying events while the node remains active instead of exposing `retry` as a final outcome +- Command results now distinguish cancellations from timeouts +- Docker, Daytona, local, and worktree sandboxes feed command stdout and stderr into the same streaming log pipeline + + + +- Run progress no longer prints successful metadata snapshot lines in the main progress stream +- Run detail headers are less noisy after removing the repeated source and sandbox path line + + + +- Fixed command diagnostics being lost on early command failures +- Fixed Daytona and worktree sandboxes losing streamed command semantics +- Fixed retros missing command timing log references diff --git a/docs/public/changelog/2026-05-01.mdx b/docs/public/changelog/2026-05-01.mdx new file mode 100644 index 000000000..2f0a21547 --- /dev/null +++ b/docs/public/changelog/2026-05-01.mdx @@ -0,0 +1,34 @@ +--- +title: "Clearer failure diagnostics and deployment docs" +date: "2026-05-01" +--- + +## Full error context in user-facing failures + +Fabro now preserves source error chains across the CLI, server, sandbox, GitHub, OAuth, MCP, tracker, and workflow paths. Previously, several errors were flattened into a single message before reaching the user, which hid the underlying network, credential, serialization, or provider failure that actually needed attention. + +This makes failures from commands such as `fabro run`, `fabro exec`, `fabro install`, `fabro dump`, and server-side run creation more actionable. The top-level message still describes the Fabro operation, while the source chain keeps the lower-level cause available in rendered output and diagnostics. + +## Self-hosting documentation refresh + +The public docs now separate local operation, self-hosted Docker, Railway deployment, and server operations into distinct pages. Older Render, Fly.io, DigitalOcean, and one-off deploy artifacts were removed so operators see the supported deployment paths instead of stale platform-specific instructions. + +This gives new server installs a clearer path from "run the binary" to "operate Fabro behind your own process manager or container platform." The Docker Compose documentation now reflects the packaged service shape used by current self-hosted deployments. + +## More + + +- Run projections now use stage vocabulary for stage completion and stage projection types +- Stage state and artifact retry fields are separated so API clients do not mix execution status with retry URLs +- TypeScript `StageState` JSON fields are typed instead of emitted as `any` + + + +- Removed the development-token environment override from normal CLI auth resolution + + + +- Fixed Docker exec stop requests running an extra command after cancellation +- Fixed `fabro dump` hiding serde errors when a run projection could not be hydrated +- Preserved exec failure diagnostics through workflow initialization, finalization, and sandbox metadata snapshots + diff --git a/docs/public/changelog/2026-05-02.mdx b/docs/public/changelog/2026-05-02.mdx new file mode 100644 index 000000000..48a501a59 --- /dev/null +++ b/docs/public/changelog/2026-05-02.mdx @@ -0,0 +1,33 @@ +--- +title: "Answer blocked runs in the web app" +date: "2026-05-02" +--- + +## Interview dock for blocked runs + +Blocked runs can now be answered directly from the run page. The new interview dock supports yes/no, confirmation, multiple choice, multi-select, and freeform questions, including write-in responses when a choice question allows them. + +The dock listens to interview events and refreshes as questions arrive, so a parallel workflow with multiple pending prompts can be drained from one place. Cancelling the run stays in the page header while the dock stays focused on the current question. + +## Principal attribution and auth routing + +Run events and run creation now carry clearer principal information for users, workers, systems, Slack interactions, webhooks, agents, and anonymous actors. API clients get explicit provenance objects instead of older actor-shaped fields that could lose where a run came from. + +This also closes attribution gaps across web, CLI, worker-token, Slack, and human-interview paths. Runs created or advanced through different surfaces now preserve who or what took the action more consistently. + +## More + + +- Run specs now include client and server provenance shapes +- Run events use unified principal shapes for user, worker, system, Slack, webhook, agent, and anonymous subjects + + + +- Bounded server readiness probes so startup and status checks fail promptly instead of waiting indefinitely + + + +- Fixed principal attribution gaps during run creation and interview callbacks +- Fixed auth routing regressions around worker tokens and human-in-the-loop callbacks +- Preserved remaining error context in provider auth, tracker, OAuth, graph rendering, and workflow command errors + diff --git a/docs/public/changelog/2026-05-03.mdx b/docs/public/changelog/2026-05-03.mdx new file mode 100644 index 000000000..d2b0fbec2 --- /dev/null +++ b/docs/public/changelog/2026-05-03.mdx @@ -0,0 +1,40 @@ +--- +title: "Run links and Daytona scope checks" +date: "2026-05-03" +--- + +## Run web URLs in API and CLI output + +Fabro now returns a run's web UI URL with run responses and stores the same URL on the `run.created` event. API clients and command output no longer have to reconstruct route shapes or guess which public web URL the server is using. + +When the web UI is enabled, `fabro run` and `fabro attach` print the link from the run event stream: + +```bash +Web UI: https://fabro.example.com/runs/01JNQVR7M0EJ5GKAT2SC4ERS1Z +``` + +Fresh runs and attached sessions use the same event-backed path, so replaying a run shows the same link that was available when it was created. + +## Daytona scope validation + +Fabro now checks Daytona API key scopes during install, `DAYTONA_API_KEY` secret updates, and `fabro doctor`. Operators see a precise missing-scope message before the first sandbox run fails. + +The validation covers the snapshot and sandbox permissions Fabro needs to create and clean up Daytona environments. This turns what used to be a generic sandbox creation failure into an install-time or diagnostics-time fix. + +## More + + +- `RunStatusResponse` and `run.created` now include `web_url` when server web UI settings are available +- Run billing responses now include non-LLM stages so the billing page can show the full run shape + + + +- `fabro run` and `fabro attach` print the run's Web UI URL when available +- Snapshot pull, create, ready, and failure events now render in run progress and logs + + + +- Fixed failed exec stages losing their output tail diagnostics +- Fixed JSON redaction replacing sandbox names that users need for debugging +- Fixed archived run overview exit nodes losing their completion color + diff --git a/docs/public/changelog/2026-05-04.mdx b/docs/public/changelog/2026-05-04.mdx new file mode 100644 index 000000000..0788bcf69 --- /dev/null +++ b/docs/public/changelog/2026-05-04.mdx @@ -0,0 +1,40 @@ +--- +title: "Faster doctor checks and GPT-5.5" +date: "2026-05-04" +--- + +## Faster, stricter LLM diagnostics + +`fabro doctor` now probes configured LLM providers concurrently instead of waiting on them one by one. Provider probe failures also count as diagnostic errors, so a broken key or unreachable provider no longer looks like a successful configuration check. + +Doctor output now preserves the underlying LLM error chain when a provider probe fails, which makes network failures, API errors, and provider-specific terminal errors easier to distinguish: + +```bash +fabro doctor --verbose +fabro model test --provider openai +``` + +## GPT-5.5 and Claude Opus 4.7 defaults + +The model catalog now includes `gpt-5.5` and `gpt-5.5-pro`, with `gpt-5.5` set as the OpenAI default. Anthropic's default model is now `claude-opus-4-7`. + +Built-in Fabro workflows were also refreshed to use the newer defaults in their own model settings. This keeps generated plans, simplify stages, and project workflows aligned with the catalog users see through `fabro model list`. + +## More + + +- `fabro doctor` now reports LLM provider probe failures as errors +- `fabro doctor` probes configured LLM providers concurrently + + + +- Built-in implementation workflows now use newer Claude and OpenAI defaults +- Built-in verify gates refresh generated docs before checking them +- Built-in Rust workflow checks now run clippy across all targets with the pinned nightly toolchain + + + +- Fixed OpenAI responses-stream terminal errors being hidden from agent sessions +- Fixed doctor output dropping source-chain details for failed LLM probes +- Fixed an LLM preflight probe regression + diff --git a/docs/public/docs.json b/docs/public/docs.json index f69811618..3000c6869 100644 --- a/docs/public/docs.json +++ b/docs/public/docs.json @@ -247,6 +247,16 @@ "tab": "Changelog", "icon": "clock-rotate-left", "groups": [ + { + "group": "May 2026", + "icon": "clock-rotate-left", + "pages": [ + "changelog/2026-05-04", + "changelog/2026-05-03", + "changelog/2026-05-02", + "changelog/2026-05-01" + ] + }, { "group": "April 2026", "icon": "clock-rotate-left",