851 commits

Author	SHA1	Message	Date
Bryan Helmkamp	e5f0290229	fix(llm): send cache_control breakpoints for Claude via OpenRouter ... Anthropic prompt caching is opt-in per request: without explicit ephemeral cache_control breakpoints in the body, no cache writes or reads ever happen. The OpenAI-compatible codec never emitted them, so every run on openrouter Claude models billed the full conversation at the uncached input rate on every turn (0 cache tokens on the billing page, confirmed by OpenRouter's activity portal). - Add a `cache_control_breakpoints` model feature declaring that a route only caches when the request marks the cacheable prefix; set it on the builtin OpenRouter Claude rows. Catalog build rejects the flag without `prompt_cache`. - Teach the Chat Completions wire shape a parts-form content variant so a message can carry the annotation; unmarked messages keep the plain-string form for compatibility with strict servers. - Mark the last system message (covers tools + system upstream) and the second-to-last user turn, counting tool results as user turns — mirroring the anthropic codec's placement so agent loops get incremental cache hits. - Extract the shared placement/opt-out policy into codec::cache and refactor the anthropic codec onto it; anthropic wire snapshots are unchanged. - Honor `provider_options.<name>.auto_cache = false` as an opt-out and consume the control key instead of merging it into the body. - Mirror the new feature through settings (fabro-config), the OpenAPI schema, and the generated TypeScript client. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-23 17:55:41 -04:00
Bryan Helmkamp	32d1b1b339	Merge remote-tracking branch 'origin/main' into provider-aware-model-aliases	2026-07-23 12:50:22 -04:00
Bryan Helmkamp	05e6507095	refactor: unify model selection and legacy-model normalization ... Consolidate duplicated resolution logic introduced by the provider-aware model alias work: - Add Catalog::resolve_selection (with SelectedModel and ready_provider) as the single home for the select -> passthrough -> default-fallback policy, replacing six hand-rolled copies across fabro-server, fabro-workflow, and fabro-llm. - Move legacy [models] row resolution into a shared LegacyModelIndex and LegacyModelError in fabro-model; delete fabro-config's parallel implementation and its LlmNormalizationError enum, plus the now-unused builtin_* catalog helpers. - Drop redundant client.resolve_request calls (and their full-request clones) from the completions and playground handlers. - Remove the redundant resolve_provider_context round-trip in resolve_start_llm and make resolve_run_model return a ProviderId instead of a never-None Option. - Replace the "<default model>" sentinel selector with a dedicated ModelSelectionError::NoDefaultModel variant. - Add a CatalogRoute trait so provider adapters call self.api_model_id(...) instead of threading catalog/provider args. - Delete the unused FromStr impl for ModelId; dedupe the CLI's id-or-alias predicate. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-23 11:07:47 -04:00
Bryan Helmkamp	65cdf52061	feat: make model aliases provider-aware	2026-07-23 10:12:25 -04:00
Bryan Helmkamp	7f25689fb6	Preserve provider-reported workflow costs	2026-07-23 07:08:04 -04:00
Bryan Helmkamp	8f47275d84	feat(llm): add Poolside Laguna models ... Add Poolside as a built-in OpenAI-compatible provider and expose Laguna S 2.1 and XS 2.1 both directly and through OpenRouter. Include vault/env credential registration, secret redaction, live coverage, catalog tests, and user documentation.	2026-07-22 18:49:16 -04:00
Bryan Helmkamp	49c30aa4a6	Let repo init use the server default environment	2026-07-22 14:44:43 -04:00
Bryan Helmkamp	2843b33d92	Simplify runs read model: single-source mappings, leaner queries ... Consolidate duplicated logic from the SQLite runs read model review: - Derive the status sort CASE and board-column filter from a new RunStatusKind::board_rank(), replacing three hand-maintained copies of the status/column mapping; add a test upserting every status variant so the migration CHECK can't silently drift - Share RunSize bucket thresholds between from_total_usd_micros and the generated size-sort CASE via RunSize::BUCKET_MAX_USD_MICROS - Resolve run selectors from a lean identity query instead of decoding every stored summary per request - Delete the RunsSortKey/RunsSortDirection adapter enums; the store sort enums now carry the wire serde names - Consolidate the workflow display-name fallback chain into WorkflowRef::display_name() (store, CLI, run lookup) - Share pagination clamping and the paginated list envelope across handlers - Reconcile now skips rows whose source seq is unchanged and batch-deletes stale rows; drop the two indexes no query can use - Hold the summary store OnceLock cell in RunDatabaseInner instead of a snapshot so late attachment reaches already-open writers - Misc: expect() on COUNT(*) sign, %err logging, shared wall-time helper, shared SQLite test fixture, dead billing fallback removed Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-22 13:55:22 -04:00
Bryan Helmkamp	6ec4c9a13d	Simplify SQLite stores after review pass ... Consolidate the legacy-import helpers (backup path naming, RFC 3339 timestamp parsing, import report) into fabro-db and reuse them from the vault, automation, variable, and environment stores. Add SecretStore::open_snapshot to collapse the repeated open/snapshot/into_vault chain. Let automation trigger canonicalization live solely in normalize_replace, replace its redundant second full validation with a targeted manual-id collision check, single-source the automation SELECT projection, and gate list_automation_runs on a lightweight existence query. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-22 13:37:31 -04:00
Bryan Helmkamp	f2cbc016ee	Clean up SQLite secrets migration and fix CLI env credential regression ... Review pass over the secrets-to-SQLite migration: - Add SecretStore::open() consolidating the connect/migrate/import-legacy sequence repeated at five call sites; fabro-agent and fabro-cli drop their fabro-db dependency - Restore process-env LLM credential lookup in the standalone CLI/agent sources via SqlVaultCredentialSource::new (regression: vault_only dropped the env fallback that VaultCredentialSource::new provided) - Fix five install tests that still asserted against the legacy secrets.json, which the importer renames to .bak - Make AppStateConfig.preloaded_vault required, deleting the fallback that re-read the already-renamed legacy file; drop the now-unused vault_path field and demote load_startup_vault to test-only - Skip the snapshot clones and CAS retry in resolve() when the vault holds no OAuth secrets (per-request hot path) - Remove dead persist_with_secret_store, the VaultSecretWrite alias, the secret_type_string one-liner (now SecretType::as_str), the impossible RowCountOverflow error, and duplicated row parsing - Run check_crypto concurrently with the other diagnostics checks Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-22 12:45:38 -04:00
Bryan Helmkamp	6860852c9c	Simplify SQLite secret storage	2026-07-22 12:45:38 -04:00
Bryan Helmkamp	d325a2c1e6	Migrate secrets storage to SQLite	2026-07-22 12:44:20 -04:00
Bryan Helmkamp	8b2830d772	feat(deploy): support Tailscale Services deployments (#560) ... Created from HEAD commit 6746bff18.	2026-07-07 22:39:00 -04:00
fabro-sh-fabro[bot]	9008058eab	Resolve secret tokens at the run boundary (worker-side, fail-closed) (#545) ... ## Summary `{{ secrets.NAME }}` tokens in workflow config (MCP transport, prepare steps, run environment) now resolve from the server vault at the run boundary — the same late-binding point where `{{ env.* }}` tokens resolve. Secret values are never persisted and never left literal in resolved commands or env; a missing or non-Token secret aborts startup with a clear error. ## What changed **`fabro-types` — `run.rs`** - `resolve_env_string` (shared choke-point for MCP and prepare) gains a `secrets_lookup` parameter and routes through `ResolveCtx::new().with_env(...).with_secrets(...)` / `resolve_with`. - `McpServerSettings::resolve_transport_env` and `RunPrepareSettings::resolve_step_env` thread the new parameter through. - `RunEnvironmentSettings::resolve_env` becomes fallible (`Result<HashMap<_,_>, ResolveError>`). Per-value error handling preserves the historical env fallback for `Namespace::Env`-only errors while failing closed for `Namespace::Secrets` errors. The intentional `as_source()` fallback is gated behind its `#[expect(clippy::disallowed_methods)]` with an explicit reason. **`fabro-workflow` — `start.rs`** - A single vault read guard is acquired once at the top of `RunSession::new`, replacing the previous per-site reads (Daytona key, etc.). - `vault_token_lookup` wraps `fabro_auth::vault_get_token` — returning `Some(value)` only for `Token`-type secrets; `Oauth` and `File` secrets become `None` (fail-closed). - The shared `secret_lookup` closure is threaded into `runtime_mcp_server`, `runtime_setup_commands`, and `resolve_env`. `resolve_docker_config` gains the same parameter and now returns `Result`. **`fabro-sandbox` — `from_environment.rs`** - `docker_config_from_environment` (server-preflight path, no vault available) retains `resolve_or_source` behavior unchanged. - New `docker_config_from_environment_with_secrets` is the vault-backed variant used by `start.rs`. **`fabro-cli` — `exec.rs`** - `fabro exec` has no vault; passes `|_| None` for secrets, preserving existing behavior with updated call signature. ### Plan summary - **B.1** — Secret lookup threaded through `resolve_env_string` / `resolve_transport_env` / `resolve_step_env` / `resolve_env` in `fabro-types`. - **B.2** — Vault-backed `secret_lookup` closure built once in `RunSession::new` and passed to all boundary resolvers in `start.rs`. - **B.3** — Persistence invariant test: a created run's persisted `RunCreated` event still carries `{{ secrets.DEPLOY_TOKEN }}` in source form, not the resolved value. - **B.4** — Verification (fmt, clippy, nextest, release build) with hermetic temp-vault tests. ### Key design decisions - **Fail closed everywhere secrets are referenced** — no source fallback for secret tokens, even in `resolve_env` which otherwise keeps the env fallback. This is enforced by checking `value.references(Namespace::Secrets)` before the fallback branch. - **Token-only** — `vault_get_token` enforces this; `Oauth` and `File` secrets silently become `None` and then hard-error via the resolver, not a panic. - **Single vault read guard per `RunSession::new`** — acquired once, shared across MCP / prepare / env resolvers, then dropped before the struct is returned. Mirrors how the Daytona key was already read. - **`fabro exec` stays unchanged behaviorally** — the added `|_| None` secrets argument makes the new signature explicit about having no vault. ### Fabro Details <details> <summary>Ran 9 stages in 82m 55s for $24.43</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 21s | – | 0 | | preflight_lint | 2m 34s | – | 0 | | implement | 46m 58s | $15.83 | 0 | | simplify_opus | 12m 43s | $4.79 | 0 | | simplify_gpt | 6m 43s | $3.18 | 0 | | verify | 6m 41s | – | 0 | | fixup | 4m 33s | $0.63 | 0 | | **Total** | **82m 55s** | **$24.43** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-8; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, timeout="1800s", script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh>	2026-07-02 17:00:20 -04:00
Scott Werner	ec0a08afb3	fix: grant organization_projects to auto-created GitHub Apps for Projects V2 (#544) ... ## What Adds the `organization_projects: write` permission to the GitHub App manifest used when Fabro auto-creates a GitHub App, in **both** install flows: - `lib/crates/fabro-server/src/install.rs` (web-UI install) - `lib/crates/fabro-cli/src/commands/install.rs` (CLI install) A test assertion in the CLI install tests guards the new permission. ## Why The GitHub Projects V2 tracker mints a scoped installation token requesting `{ "issues": "write", "organization_projects": "write" }` (`create_installation_access_token_for_projects`, `fabro-github/src/lib.rs`). GitHub only lets an installation token request a **subset** of the permissions the app was granted at install time — and `organization_projects` was never in the manifest. So on any auto-created Fabro app, the token request comes back **422** and the tracker fails before it can make a single GraphQL call. `issues: write` (also requested by that helper) is already covered by the manifest; `organization_projects` was the missing piece. ## Note on rollout Manifest `default_permissions` are applied at **app-creation time**, so this only affects **newly** auto-created apps. Existing apps need the permission added manually in their settings, and each installation must approve it. ## Follow-up (not in this PR) The `422` branch in `mint_installation_token_with_jwt` reports "GitHub App does not have access to repository {repo}" — which misattributes a missing-permission failure to repository access. Worth softening the message to mention permissions too; left out here to keep this PR focused on the scope change. ## Test - `cargo nextest run -p fabro-cli -- manifest_includes_callback_urls_and_setup_url` passes. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-01 22:13:26 +00:00
Scott Werner	3e0db1febf	feat: grant Dependabot alerts read/write to auto-created GitHub Apps (#543) ... ## What Adds the `vulnerability_alerts: write` fine-grained permission to the GitHub App manifest used when Fabro auto-creates a GitHub App, in **both** install flows: - `lib/crates/fabro-server/src/install.rs` (web-UI install) - `lib/crates/fabro-cli/src/commands/install.rs` (CLI install) `write` on `vulnerability_alerts` grants both read and write of Dependabot alerts (write implies read for fine-grained permissions). The two manifest builders are byte-for-byte identical by design, so both are updated together. A test assertion in the CLI install tests guards the new permission. ## Why We need auto-created Fabro apps to be able to read and manage Dependabot alerts. ## Note on rollout Manifest `default_permissions` are applied at **app-creation time**, so this only affects **newly** auto-created apps. Any app already created won't pick this up automatically — the owner must add the permission in the app's settings, and each existing installation must approve the new permission request. ## Test - `cargo nextest run -p fabro-cli -- manifest_includes_callback_urls_and_setup_url` passes. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-01 22:05:25 +00:00
Bryan Helmkamp	bec4b90ad3	Move environments to SQLite storage (#539) ... ## Summary Move server-managed environments from sibling TOML files into SQLite, matching the storage model already used by variables and secrets. This adds: - an `environments` SQLite table with DB-level validation for IDs, revisions, providers, network modes, booleans, and JSON fields - a SQLite-backed `EnvironmentStore` with cached synchronous reads, transactional create/replace/delete, synthetic unpersisted `local`, and `default` as an ordinary seeded row users can delete - one-time legacy import from `environments/*.toml` next to the active server `settings.toml`, including relative Dockerfile path inlining and backup rename to `environments.imported-<timestamp>.bak` - install/test/CLI seeding of `default` directly into SQLite instead of writing `environments/default.toml` - docs updates for API/SQLite-managed server environments and legacy import behavior The REST API shape is unchanged; path Dockerfile sources remain rejected over the environments API. ## Testing - `cargo nextest run -p fabro-db -p fabro-environment` - 15 passed - `cargo nextest run -p fabro-server --features test-support environments` - 16 passed - `cargo nextest run -p fabro-server --features test-support install` - 60 passed - `cargo nextest run -p fabro-server --features test-support create_run_rejects_disabled_sandbox_provider` - 1 passed - `cargo nextest run -p fabro-server --features test-support system_sandbox_provider` - 2 passed - `cargo nextest run -p fabro-cli install` - 132 passed - `cargo +nightly-2026-04-14 fmt --check --all` - `cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings`	2026-07-01 10:31:58 -04:00
Bryan Helmkamp	2307468bc6	fix(cli): use server catalog for provider login (#529) ... ## Summary `fabro provider login --server ... --provider openrouter` now asks the selected Fabro server for provider metadata before reading, validating, and storing API keys, so server-enabled providers are accepted even when the local CLI catalog does not know them. This adds a server-side credential test endpoint that validates submitted API keys against the server's effective catalog without persisting them, then keeps saving the resulting secret to the selected target server. OpenAI Codex device login remains client-side for the browser/device flow, with the resulting OAuth credential stored on the selected server. The OpenRouter docs and model docs are updated to use the current `--provider openrouter` login syntax and clarify that remote deployments need the server host settings updated. ## Testing - `cargo nextest run -p fabro-client -p fabro-server -p fabro-cli provider` - `cargo +nightly-2026-04-14 fmt --check --all` - `cargo +nightly-2026-04-14 clippy -p fabro-client -p fabro-server -p fabro-cli --all-targets -- -D warnings` - `rg -n "provider login openrouter|fabro provider login [a-z]" docs/public lib/crates/fabro-cli/tests lib/crates/fabro-cli/src -g '*.md' -g '*.mdx' -g '*.rs'` --- [](https://github.com/EveryInc/compound-engineering-plugin) 🤖 Generated with GPT-5 (context compacted, extended thinking) via [Codex](https://openai.com/codex)	2026-06-26 08:46:38 -04:00
Scott Werner	ee7453418b	Unify @file inlining under an ImportableTemplate type (prompt + goal) (#527) ... ## What Introduces an `ImportableTemplate` type that unifies the "inline content **or** `@path` file import" concept used by node `prompt`s, the graph `goal`, and `output_schema`. This is the last template-side piece of the interpolation unification: a single named type now owns the `@`-classification and static-reference validation that was previously hand-rolled in three places. This is a **behavior-preserving refactor** — no user-visible change. ## How - New `ImportableTemplate { Inline(String), Import { path } }` in `transforms/importable_template.rs`, with `parse` (classifies a value — a leading `@` marks a file import), `import_path`, and `validate` (rejects template syntax in an import path). Callers of templated fields classify the **already-rendered** string, because a leading `@` can be produced by rendering (e.g. `{{ inputs.prompt_file }}` → `@prompts/work.md`). - `prompt` + `goal`: render the inline value, then — if it's an `@file` import — load and render the file contents via the type. The missing-file → literal passthrough is preserved. - `output_schema`: shares the same classification but is loaded **verbatim** (it is intentionally not a template), keeping its hard-error-on-missing-file behavior. - Deletes the dead `resolve_file_ref` helper (no non-test callers) and inlines the trivial `render_file_contents` wrapper. - Migrates the `FilesystemFileResolver` coverage (tilde, `..`, fallback-dir precedence, missing file) — which previously only existed through `resolve_file_ref`'s tests — onto direct `file_resolver` tests. `TemplateTransform` and the import transform are untouched, so goal-before- prompts ordering and the goal-self-reference guard are preserved exactly. ## Scope Covers the DOT node `prompt` + graph `goal` `@file` path. The settings-layer `run.goal` resolution is intentionally left as-is — it uses a different model (interpolates env into the file path and does not render file contents), so folding it in would be a semantic change, not a refactor. That convergence can be a deliberate follow-up. ## Testing - `cargo nextest run -p fabro-workflow` — 1182 passed (31 e2e/credentialed skipped). New unit tests on the type (classification, validation) and the migrated `FilesystemFileResolver` tests. - Regression net kept green: file-inlining (prompt/goal, output_schema verbatim/error/routing, `{% include %}` rooting, fallback dir), the `TemplateTransform` goal/self-reference/ordering tests, and the cross-pass `reports_goal_self_reference_once_across_passes`. - `cargo +nightly fmt --check --all` and nightly `clippy --workspace --all-targets -- -D warnings` clean. 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-25 15:51:46 -04:00
Scott Werner	8a7ad7200b	feat(types): introduce ResolvedMcpEntry for run agent MCP entries (#526) ... ## What Changes `RunAgentSettings.mcps` from `HashMap<String, McpServerSettings>` to `HashMap<String, ResolvedMcpEntry>`, a two-state enum: - `Resolved(McpServerSettings)` — an inline, fully-resolved MCP server (every code path produces this today). - `Reference { id, enabled }` — an unresolved reference to a named server in the MCP catalog. This is the **type-shape foundation only**: every current path still produces `Resolved`, and no reference parsing or catalog lookup is added here. It unblocks a later server-side pass that swaps `Reference` → `Resolved` against the MCP server store before a run spec is persisted, so persisted runs stay self-contained snapshots. ## Why this shape - `ResolvedMcpEntry` is `#[serde(untagged)]` with `Resolved` first, so a resolved entry (de)serializes as a bare `McpServerSettings` with no enum tag — preserving backward compatibility with run specs persisted before the enum existed. - `McpServerRef` uses `deny_unknown_fields`, so the two variants can never collide (`McpServerSettings` requires `name` + `transport`, which a reference rejects). - `McpServerRef.id` is a plain `String`, keeping `fabro-types` decoupled from the MCP store crate. ## Consumers updated - **fabro-config** `resolve_agent`: wraps each enabled inline entry as `Resolved`, reusing the shared `resolve_enabled_mcps` enable-filter. - **fabro-types** `RunNamespace::substitute_variables`: only walks `Resolved` entries (references carry no templates). - **fabro-workflow** `operations/start.rs`: extracts `Resolved` at the post-persistence worker-startup consumer; a surviving `Reference` is an invariant violation, guarded with `debug_assert!` plus a hard error. - **fabro-cli** `exec.rs`: the `run.agent.mcps` fallback for `fabro exec` keeps only `Resolved` inline servers; catalog references are run-only on this CLI-direct path (no server-side resolver). ## Tests - Back-compat round-trip proving old-format bare-`McpServerSettings` maps (JSON and TOML) deserialize as all-`Resolved`. - A `{ id, enabled }` value parses as `Reference` while a full server config parses as `Resolved`. - `Resolved` serializes back out as a bare `McpServerSettings`. Independent of the in-flight MCP server store and OpenAPI-spec PRs; mergeable on its own. 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>	2026-06-25 15:50:36 -04:00
Scott Werner	b6ecbe20a9	fix(mcp): honor inline enabled=false and per-server tool_timeout (#520) ... ## What Two latent fixes to MCP server config handling, independent of any new feature: 1. **`enabled = false` is now honored for inline MCP servers.** Entries under `[run.agent.mcps.*]` and `[cli.exec.agent.mcps.*]` accepted an `enabled` flag that resolution silently ignored, so a disabled server still started. Disabled entries are now dropped from the resolved set. Absent `enabled` still means enabled. 2. **Explicitly configured empty `cli.exec.agent.mcps` sets are preserved.** If every `cli.exec` MCP entry is disabled, `fabro exec` now treats that as an intentional empty override instead of falling back to `run.agent.mcps`. 3. **Per-server `tool_timeout_secs` now applies to MCP tool calls.** The value was carried through config but never reached the call path. The connection manager now owns each server timeout and applies it when calling tools. ## Testing - New and updated tests cover StickyMap same-key replacement across layers, `enabled = false` skipped for run and `cli.exec`, absent `enabled` kept, higher-layer disable shadowing, explicit empty `cli.exec` MCP overrides, and configured tool timeout behavior. - `cargo +nightly-2026-04-14 fmt --check --all` - `cargo nextest run -p fabro-config -p fabro-agent -p fabro-mcp`: 737 passed, 93 skipped. - `cargo +nightly-2026-04-14 clippy -p fabro-config -p fabro-agent -p fabro-mcp -p fabro-cli --all-targets -- -D warnings` - `cargo test --locked -p fabro-workflow --test it --no-run` ## Notes - **Behavior change** worth a changelog entry: disabled inline MCPs are now actually disabled, explicit empty `cli.exec` MCP overrides are respected, and per-server tool timeouts now take effect. - First of a short series adding server-managed MCP servers; this PR is self-contained and independent of the others. 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>	2026-06-24 16:17:27 -04:00
Scott Werner	5b3b3b0a6b	Resolve {{ env.* }} in MCP transport config at the run and exec boundaries (#511) ... First **enhancing** PR of the interpolation unification: now that the reducing PRs have pinned interpolation to the workflow config language, this adds real `{{ env.* }}` resolution for MCP server transports — at **both** the `fabro run` and `fabro exec` boundaries. Independent off `main` — **no dependency on #510** (zero file overlap; #510 touches the control-plane server settings). Builds on the already-merged InterpString foundation (#472). ## What users get MCP server transport fields now interpolate `{{ env.* }}` tokens, resolved **at the boundary where the server is actually launched**: - **stdio / sandbox**: `command`, `args`, and per-server `env` values - **http**: `url` and `headers` A literal value passes through unchanged; a `{{ env.NAME }}` token is resolved against the launching process's environment. **Missing env var is a hard error** (D3) instead of the previous behavior where the raw token leaked downstream as literal text. Reserved `secrets`/`inputs` tokens (no resolver here yet) surface as a loud `Unavailable` error rather than passing through. Resolution happens at the run/exec boundary, not in the shared config resolve layer, so `fabro validate` stays portable (env presence is a runtime concern, not a validation one). ## Both consumers, one resolver `fabro run` and `fabro exec` read the **same** MCP representation — `run.agent.mcps` and `cli.exec.agent.mcps` both parse through `McpEntryLayer` (InterpString) and collapse via the same `resolve_mcp_entry`. Originally only the run boundary resolved env, so a file-sourced `[cli.exec.agent.mcps.*.env] KEY = "{{ env.X }}"` (from `~/.fabro/settings.toml`) resolved under `run` but **leaked the raw token under `exec`** — a silent asymmetry that would generate confusing bug reports. This PR closes that by moving the resolution onto the type as `McpServerSettings::resolve_transport_env` (in `fabro-types`, next to the `vars` half `substitute_mcp_transport`), so both consumers share one resolver with no drift: - `runtime_mcp_server` (run worker) → resolves against the worker process env - `fabro exec` → resolves against the CLI process env `runtime_mcp_server` becomes a thin wrapper that just adds the server name to the error. ## Tests - `fabro-types`: 5 `resolve_transport_env` unit tests — literal passthrough, stdio command+env, http url+headers, sandbox env, missing-env hard error, and the reserved-`secrets` loud-fail case. - `fabro-workflow`: the 5 existing `runtime_mcp_server_*` tests are unchanged and now exercise the shared resolver through the wrapper. Files: `fabro-config/src/resolve/run.rs`, `fabro-types/src/settings/run.rs`, `fabro-workflow/src/operations/start.rs`, `fabro-cli/src/commands/exec.rs`. Verified: `cargo build`, nightly `clippy --all-targets -D warnings`, nightly `fmt --check`, and `cargo nextest run -p fabro-types -p fabro-workflow -p fabro-config -p fabro-cli` (2679 passed with ambient provider keys stripped; the one failure otherwise is the pre-existing ambient-`*_API_KEY` flake, unrelated to MCP). > Note: the shared resolver takes `Resolved.value` and drops interp `Provenance` (consistent with every other resolved path today — `Provenance` currently has zero consumers, and resolved MCP transport values never surface in logs/events/API). Whether MCP env should carry provenance for precise redaction vs. relying on content-based `fabro-redact` is tracked as an open decision under D4. 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-18 19:14:04 -04:00
Scott Werner	2bd04c7935	Demote control-plane config to plain String; native FABRO_WEB_URL read (#510) ... Third reducing PR of the interpolation unification (**D11 resolution (c)**): the control plane never interpolates. `InterpString` is now strictly the user-facing workflow config language; server identity, storage, listen, object-store, and GitHub App identifiers are plain `String`, consumed where needed with no resolution point. ## Demoted to `String` (was `InterpString`) Both the layer and resolved types: - `server.listen.unix.path`, `server.api.url`, `server.web.url` - `server.storage.root`, `server.artifacts.prefix`, `server.slatedb.prefix` - object store: `Local.root`, S3 `bucket` / `region` / `endpoint` (shared by artifacts + slatedb) - `github.app_id` / `client_id` / `slug` **Kept `InterpString`:** `slack.default_channel` (run-time consumption — the one server-defined survivor). `server.listen.tcp.address` stays the `SocketAddr` `parsed_value` special case. ## Native `FABRO_WEB_URL` read Deployment-time late binding now goes through a native env read instead of a `{{ env.* }}` token: `FABRO_WEB_URL` overrides `server.web.url` (**env override > settings literal > default**), applied in `canonical_origin` and reused by the JWT issuer, cookie-secure check, and system-info. `docker/split-web` no longer ferries the value through a settings token (compose still sets the env var). `canonical_origin`'s error message now advertises a knob that is actually true for everyone. ## Behavior change (release notes) - `{{ env.* }}` / `{{ vars.* }}` tokens in the demoted server fields are now **literal text**, not interpolated. The resolve layer emits `warn_if_demoted_template` for every demoted field, so operators with tokens still in server config **fail loud** rather than silently treating the token as a literal. - Operators who relied on env-based storage location should use the existing native `FABRO_STORAGE_DIR` (`--storage-dir`) override. `FABRO_STORAGE_ROOT` promotion is intentionally deferred (not a proven need). ## Cleanup `fabro-server`'s `crate::interp` shrinks to just the process-env lookup facade; `resolve_interp` / `_path` / `_with` and the `AppState::resolve_interp` seam are deleted (nothing resolves server-scope `InterpString` anymore). ## Verification - `cargo build --workspace` ✅ - `cargo +nightly clippy --workspace --all-targets -- -D warnings` ✅ (incl. the `as_source` gate) - `cargo +nightly fmt --check --all` ✅ - `cargo nextest run --workspace`: 6305 passed; added two tests covering the `FABRO_WEB_URL` override precedence (env-wins and settings-literal fallback). 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-18 10:03:14 -04:00
Scott Werner	accd91a0a6	Demote non-interpolating config fields to plain String (#492) ... # Demote non-category leak fields to plain `String` Second slice of the interpolation unification — the first **reducing** PR stacked on the foundation (#472), per the reduce-first sequencing: narrowing changes land before capability additions. (The other reducing slice, the DOT de-templating, already landed independently as #474.) ## Why The target model gives `InterpString` to fields in five categories — `command` / `script` / `headers` / `env` / `url` — wherever they appear. A handful of fields were typed `InterpString` but are *identifiers or commit content*, not in any category: - `run.model.provider` / `run.model.name` - `cli.exec.model.provider` / `cli.exec.model.name` - `run.git.author.name` / `run.git.author.email` - `run.scm.owner` / `run.scm.repository` Their consumers never resolved them — they leaked raw source text via `as_source()`. This PR demotes them to plain `String` (layer and resolved structs) with **no interpolation**. ## The principle: only `InterpString` fields access variables These fields are dropped from the variable substitute pass entirely, so both `{{ vars.* }}` and `{{ env.* }}` are now literal text. This **removes an incidental behavior**: run-scoped plain-`String` fields used to get `{{ vars.* }}` substituted via the String pass (a lucky accident), while `env` always leaked literally. Variable access becomes deliberate and typed rather than accidental; if any of these fields should support variables later, that's a controlled promotion back to `InterpString`. ## Behavior changes (honest list) - **The incidental run-scoped `{{ vars.* }}` substitution on these eight fields stops working.** To keep the removal visible rather than silent, a `tracing::warn!` fires at resolve time when a demoted field still contains claimed template tokens (`warn_if_demoted_template`). Unclaimed `{{ ... }}` text (jq programs, Go templates) never interpolated and does not warn. - `{{ env.* }}` / `{{ secrets.* }}` / `{{ inputs.* }}` never resolved on these fields, so nothing else changes. ## Added in review: D11 demotions (separate commit, revertable) The rule got refined during review: a field is `InterpString` iff it is in one of the five categories **and resolved at the run boundary** (the only point where `vars`/`secrets`/`inputs` exist — they're server state, so connect-time and startup-time fields can't reach them even in principle). A separate commit applies the clean subset so it can be cherry-picked out if we change course: - `cli.target.http.url` / `cli.target.unix.path` — consumed at CLI connect time; consumers only ever leaked raw source, so nothing working is removed. - `run.working_dir` — **the outlier; see the PR comment.** Its `{{ vars.* }}` substitution worked; demoted on the category test alone. ## What's deliberately NOT here - The **control-plane fields** (`server.storage.root` / `listen.unix.path` / S3 fields / `github.app_id/client_id/slug` / `server.api.url` / `server.web.url`) — untouched here, demoted in a follow-up PR. **Resolved during review** (see the resolution comment): `InterpString` was conflating the user-facing workflow language with the internal control plane. Control-plane fields never interpolate; the few deployment knobs that need late binding (e.g. `FABRO_WEB_URL`, whose only real usage is the split-web PoC ferrying a compose env var across a file mount) become explicit native `EnvVars` reads, and `fabro-server/src/interp.rs` shrinks to deletion. `slack.default_channel` stays `InterpString` (consumed with run context). ## Implementation notes - Consumers move from `as_source()` to direct `String` access; the foundation's `#[expect(disallowed_methods, ... demotion pending ...)]` annotations for these fields are removed (no longer `InterpString`). - `fabro-checkpoint`'s author plumbing and `fabro-manifest`'s scm fields simplify accordingly. ## Verification - `cargo build --workspace` - `cargo nextest run --workspace` → 6684 passed, 181 skipped - `cargo +nightly fmt --check --all` - `cargo +nightly clippy --workspace --all-targets -- -D warnings` → clean 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-16 13:16:31 -04:00
Ryan Neal	d5b2220ed3	feat(llm): Amazon Bedrock provider — Converse codec, SigV4 + API-key auth (#459) ... Adds **Amazon Bedrock** as an opt-in built-in provider, over Bedrock's unified **Converse / ConverseStream** API. One codec serves every Converse-capable family — Claude, Amazon Nova, Meta Llama, Mistral, DeepSeek, Moonshot Kimi, Z.AI GLM, MiniMax, NVIDIA Nemotron, and OpenAI gpt-oss — because AWS translates the envelope to each model's native dialect server-side. Auth is either **AWS SigV4** (the default credential chain — env / profile / IMDS / IRSA / SSO, resolved per request so sessions refresh) or a **Bedrock API key** (`AWS_BEARER_TOKEN_BEDROCK`, bearer). Disabled by default (the Ollama / OpenRouter opt-in pattern). This is the redo of #459's original Claude-only `InvokeModel` adapter, rebuilt on the gateway-refactor seams (#481–#497). @depopry's SigV4 signer, AWS event-stream frame decoder, `BedrockAuth`, the `aws_sigv4` credential grammar, `AdapterKind::Bedrock`, region-from-base_url, and the lean-deps decision are preserved and authored by him on the first two commits; the per-family `BedrockCodec` trait he wrote turned out to be the crate-wide `Codec` seam in miniature, so the refactor promoted exactly that shape. The original Claude-only description is preserved in a comment below. ## What's here - **`AdapterKind::Bedrock` × `CodecKind::BedrockConverse`** on the route, plus the `aws_sigv4` credential source (no static secret — the adapter signs at request time; `fabro-auth` stays AWS-free). *(@depopry)* - **SigV4 signer + AWS event-stream `FrameDecoder`** on the lean AWS stack (no `aws-sdk-bedrockruntime`; transport stays on `fabro-http`). Re-targeted at Converse's direct-JSON stream frames; the signer resolves credentials per request. *(@depopry)* - **`bedrock_converse` codec** — Converse envelope (`system[]`, typed content blocks, `inferenceConfig`, `toolConfig`), prompt caching via `cachePoint`, thinking-signature round-trip through `reasoningContent`, usage mapped onto the disjoint `TokenCounts` buckets, `provider_options.bedrock` passthrough. Plus the adapter shell and an event-stream byte loop beside the transport's shared SSE loop. - **Catalog**: `bedrock.toml` (Claude incl. Fable 5, Nova 2, Llama 4, Mistral, DeepSeek, Kimi, GLM, MiniMax, Nemotron, gpt-oss — cross-region inference-profile ids, per-model `billing_policy` so Claude bills Anthropic-style) and a companion **`bedrock-openai`** provider for GPT-5.5/5.4 over the `bedrock-mantle` Responses endpoint (pure config over the existing `openai_responses` codec, zero new code). - Secrets registry (`AWS_BEARER_TOKEN_BEDROCK`), gitleaks rules for both Bedrock key formats, the `docs/integrations/bedrock` guide, and live e2e tests. ## Live verification (confirmed end-to-end against a real AWS account) Verified on a real Bedrock account (us-east-2, SigV4 + bearer): - **SigV4 + Converse** — multiple families (Claude, Nova, DeepSeek, …) via the full settings → catalog → route → adapter → codec path. - **ConverseStream** — streaming deltas through the workflow engine. - **Multi-turn tool use** — agent loop with tool calls round-tripping (no-arg tools included). - **Multi-model routing** — Claude + DeepSeek pinned in one run through the single Converse codec. - **mantle Responses** — `openai.gpt-5.5` answered via the `bedrock-openai` provider (bearer auth). The exercise caught and fixed several issues that unit tests (static creds, mocked transports) could not — see the follow-up commits below. ## Follow-up fixes from live testing (commits on top of the foundation) 1. **Worker AWS env** — the workflow worker scrubs its env to an allowlist, so SigV4 (which re-resolves from the ambient chain per request) couldn't work through `fabro run`. The AWS credential-chain inputs now cross into the worker. 2. **Vault bearer key** — Bedrock was the only key-based provider missing a `vault:` credential ref, so `fabro secret set AWS_BEARER_TOKEN_BEDROCK` silently didn't feed it. Now resolves env → vault → SigV4. 3. **Converse tool-encoding hardening** — a no-arg tool call's `toolUse.input` is now a `{}` object (Bedrock rejects null), and every tool `inputSchema` gets a top-level `type: "object"` (strict families like DeepSeek reject a typeless schema Claude tolerates). 4. **Nova output cap** — `amazon.nova-2-lite` max_output 65536 → 65535 (Bedrock's per-request limit). Earlier fixes already folded into the foundation commits: the `aws-config` sleep-impl (default chain panicked) and AWS error-body decoding (top-level `message`/`Message`/`__type` → proper messages instead of "Unknown error"). ## Manual testing & setup See `docs/integrations/bedrock` — now documents the non-obvious account setup that live testing surfaced: the per-Region Anthropic use-case approval, `aws-marketplace:Subscribe` for third-party models, the Fable 5 / Mythos-class data-sharing opt-in, and the bearer-vs-SigV4 precedence override for running Converse + mantle side by side. ## Open decision / discussion - **Model-id naming** — Bedrock rows use dotted ids mirroring Bedrock's native inference-profile ids (`us.anthropic.claude-sonnet-4-6`, `openai.gpt-5.5`), which also makes them the wire `api_id`. Third scheme alongside bare ids and OpenRouter's `vendor/model` slashes. No collision risk (enforced at catalog build). Open to a uniform scheme if preferred. - **`BEDROCK_API_KEY` alias** — see the comment thread; the AWS console hands some users `export BEDROCK_API_KEY=` while the SDK-standard var is `AWS_BEARER_TOKEN_BEDROCK`. Question of whether to accept both. ## Deferred (named follow-ups) - **`qwen.qwen3-coder-next`** — omitted pending a verified Bedrock model/inference-profile id (its fabro id isn't a valid Bedrock identifier; needs an explicit `api_id`). Re-add once confirmed via `aws bedrock list-inference-profiles`. - **Claude Mythos 5** — Anthropic-Messages-only on `bedrock-mantle` (limited preview). - **Converse structured output** (`response_format` rejected with a clear error). - **`reasoning_effort` on Converse rows** via `additionalModelRequestFields` (the `bedrock-openai` GPT rows already accept effort levels). - **CountTokens** route (`count_input_tokens` returns `None`). ## Verification `cargo nextest run --workspace`: green except the pre-existing environment-dependent fabro-workflow failures (identical on main). clippy `-D warnings` + pinned-nightly fmt clean. Codec unit tests + adapter httpmock tests + frame-decoder/signer locks. 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com> Co-authored-by: Scott Werner <scott@sublayer.com> Co-authored-by: Scott Werner <stwerner@vt.edu>	2026-06-16 11:46:49 -04:00
Bryan Helmkamp	bc0bda73a6	feat(web): add server-managed Environments CRUD settings UI (#462) ... ## What Adds a CRUD interface for **server-managed Environments** at `/settings/environments`, driven by the `/api/v1/environments` REST API (list / create / retrieve / replace / delete), and reshapes how built-in environments are provisioned and protected. The page lives in the **Workflows** settings nav section (also introduced in this branch), positioned before Variables. ## Why The Environments REST API shipped (#453) but had no UI — environments could only be managed via the API/CLI. This gives operators a web UI alongside Variables and Secrets, and along the way tightens the model: environments are seeded at install time (not silently re-created on every boot), and the `default` fallback is an ordinary, deletable environment. ## Web UI **Pages & component** - `settings-environments.tsx` — list view: provider badge, image/resource summary, row actions (Edit/Delete). **"New environment" is a dropdown** of the enabled sandbox providers; the chosen provider is fixed for the environment's lifetime. - `settings-environments-new.tsx` / `settings-environments-edit.tsx` — create/edit flows; create reads the provider from a query param. - `environment-form.tsx` — shared form, reorganized: - **General** panel (merged identity + image): id, and an **image-source selector** (Image reference *vs* inline Dockerfile) that shows, requires, and sends only the selected, mutually-exclusive source. - **Resources**: CPU / memory / disk as **range sliders** (CPU 1–8, memory 1–16 GB, disk 1–20 GB), each always writing a concrete value. - **Environment variables** key/value editor. - **Advanced** progressive-disclosure section holding **Network** (a single "Block all network access" toggle — allow-all vs block) and **Lifecycle** (preserve / stop-on-terminal / auto-stop). Opens by default when any advanced value is non-default. - The in-form **provider control and the Labels editor were removed** — labels remain API-managed and are round-tripped untouched so UI edits never clear them. **Data layer**: `environmentsApi` client, `queryKeys.environments`, `useEnvironments` / `useEnvironment` SWR hooks. **Nav & routing**: "Environments" item in the Workflows section before Variables; routes registered in `router.tsx`. ## Backend: seed at install, deletable `default` - **Seeding moved to install time.** The server no longer seeds built-ins on startup; `EnvironmentStore::load_or_seed` → `load` (load-only). A new public `seed_environments(dir)` (idempotent, preserves operator edits) is called by both the web installer and the CLI installer. An uninstalled instance therefore has no managed environments, and a run selecting an absent environment fails explicitly (`unknown environment: default`) rather than resurrecting a built-in. - **`default` is no longer protected.** The delete guard and the `Protected` error variant are gone; deleting `default` succeeds (204) and removes the run fallback on purpose — forcing an explicit choice. `local` is unchanged (reserved, in-memory). - **`volumes` removed** from environment settings across the OpenAPI spec, generated Rust + TS clients, config layers, sandbox/server/workflow plumbing, docs, and tests. ## API contract details honored - Edit sends the environment `revision` as `If-Match`; 409 conflicts surface a "changed since you opened it" message. - The REST API accepts inline Dockerfiles only — the form never sends a Dockerfile path. ## Verification - Rust: `cargo build` (touched crates) ✅, `cargo nextest -p fabro-environment` 21/21 ✅, server env unit + `tests/it` integration 2/2 + 15/15 ✅, `clippy` (nightly, touched crates, all targets) clean ✅, `fmt --check` clean ✅. Full `--workspace` suite not run here — worth a CI pass. - Web: `bun run typecheck` ✅, `bun run build` ✅, `environment-form.test.ts` 5/5 ✅. Web suite: 512 pass / 1 unrelated pre-existing `RunDetail` failure. - **Not visually verified in-browser** — the local app is login-gated and automated loads redirect to `/login`; rendering of the form, the New-environment dropdown, and `default` delete should be confirmed in a logged-in session. 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Co-authored-by: fabro-sh-0530[bot] <281434857+fabro-sh-0530[bot]@users.noreply.github.com> Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: Release Repro <release-repro@example.com>	2026-06-13 08:44:38 -04:00
Scott Werner	23d3644787	feat(llm): catalog-estimated completion cost on Response (#494) ... Standalone pre-OpenRouter step, pulled forward from the #438 triage (the gateway-refactor plan's "additive feature PR alongside the redo"): completion responses carry a USD cost with provenance. ## What's here **`Response.cost_usd` + `Response.cost_source`** — new optional fields (`skip_serializing_if` keeps the wire shape byte-identical when unset). `CostSource` (`authoritative` | `estimated`) lives in fabro-model's billing vocabulary next to `UsdMicros`/`TokenCounts`, since the API layer reuses it. **`fabro-llm/src/cost.rs`** — `estimate_cost_usd`, a thin wrapper over the existing `Catalog::price_tokens` billing machinery (billing-policy- and speed-aware), ported from #438's prototype with attribution. One fix over the prototype: model aliases and provider names are canonicalized before building the `ModelRef` — `ModelPricing::bill` rejects non-canonical refs, so the original would silently skip cost on alias requests (caught by a new test). **Client-level stamping** — one generic post-decode site instead of #438's ~8 per-adapter sites (which predate the codec refactor): `Client::complete` stamps blocking responses and `Client::stream` stamps `Finish` events, beneath the middleware chain so middleware observes final responses. Codecs stay wire-translation-only — zero wire-snapshot churn — and every registered adapter (including custom `register_provider` ones) gets the same treatment. Stamping never overwrites an existing cost, so future authoritative in-band costs (OpenRouter) take precedence by construction. **API surface** — `cost_usd`/`cost_source` on `CompletionResponse` (OpenAPI spec + handler + regenerated TS client). The streaming endpoint already carries cost implicitly since `Finish` events serialize the `Response` verbatim; this makes the blocking surface match. `CostSource` reuses the canonical fabro-model type via `with_replacement`, with the standard round-trip test pinning type identity and JSON parity. ## Deliberately not here (stays with the OpenRouter redo per the plan's hard rule) - Authoritative `usage.cost` parsing in the `openai_compatible` codec wire structs - Cached-token usage parsing (changes observable usage values) - Per-model `billing_policy` schema field ## Verification - `cargo nextest run --workspace --no-fail-fast`: 6701 passed; only the known 5 pre-existing environment-dependent fabro-workflow failures (identical on main) - All fabro-llm wire snapshots unmodified; new pins: cost estimation unit tests (incl. alias canonicalization), Client stamping tests (blocking, streaming, beneath middleware, no-catalog), fabro-api `CostSource` round-trip - clippy `-D warnings` + pinned-nightly fmt clean; `bun run typecheck` clean in fabro-web Independent of the route-vocabulary work in #493 — branches directly off main. After both land, the OpenRouter redo shrinks to config + typed codec params + authoritative-cost decode. 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-06-11 16:55:47 -04:00
Bryan Helmkamp	a4e8987da8	feat(llm): add Claude Fable 5 support (#482) ... ## Summary Adds Anthropic Claude Fable 5 as a first-class Fabro model without changing the default Anthropic model. The catalog now exposes `claude-fable-5` with `fable` and `claude-fable` aliases, 1M context, 128k max output, effort levels, vision/tools, prompt caching, and the documented pricing. The Anthropic adapter now handles Fable's API behavior directly: it uses the `claude-fable-5` API ID, omits the legacy 1M context beta header, avoids injecting default `thinking`, preserves `output_config.effort`, omits deprecated `temperature`/`top_p` sampling fields for Fable, and rejects unsupported manual enabled/disabled thinking configs locally. Fable refusals are converted into content-filter LLM errors with `stop_details` preserved. Those refusal errors are fallback-eligible, so existing `run.model.fallbacks` chains work for both prompt and agent paths, while no-fallback refusals surface clearly as LLM errors. ## Live QA Manually exercised the PR branch against a live Anthropic API key from `~/.fabro.bak/.env.bak` using a temporary local harness that was removed before commit. The run covered non-streaming completion via `fable`, token counting via `claude-fable`, streaming completion, the deep model-test path with tools/reasoning, local rejection of manual thinking config, and a live refusal probe. The live run initially exposed Anthropic's Fable rejection of `temperature`; this PR now strips deprecated sampling fields for Fable and the live harness then passed 6/6 checks. ## Testing - `cargo test -p fabro-llm --test live_fable_manual -- --nocapture --test-threads=1` -> 6 passed against live Anthropic, temporary harness removed afterward - `cargo nextest run -p fabro-llm encode_fable_uses_api_id_effort_and_omits_1m_beta` - `cargo nextest run -p fabro-model -p fabro-llm -p fabro-workflow` -> 1808 passed, 41 skipped - `cargo +nightly-2026-04-14 fmt --check --all` - `cargo insta pending-snapshots` -> no pending snapshots - `git diff --check` --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-06-10 14:01:56 -04:00
Scott Werner	ce404cddef	Interpolation foundation (InterpString v2) (#472) ... # Interpolation foundation (InterpString v2) First step of unifying config-string interpolation across Fabro. This PR is the **behavior-neutral foundation** only — it introduces the type machinery and a clippy gate, but changes no field's interpolation behavior. The actual field work follows as separate stacked PRs, sequenced **reduce-first**: narrowing changes (demote fields that shouldn't interpolate, de-template DOT attrs) land before capability additions (resolve env in MCP / prepare / hooks). ## Why Config strings interpolate `{{ ... }}` inconsistently today — some fields resolve `{{ env.X }}`, others are typed as if they do but silently pass the literal template text downstream. We're converging on three field types (`String`, `InterpString`, and later an importable template for prompts/goals) with four namespaces (`env`, `vars`, `secrets`, `inputs`). This PR lays the `InterpString` foundation; it does not migrate any field. ## What's in it - Segments generalize to `Token { namespace, name }` with a `Namespace` enum (`env`/`vars`/`secrets`/`inputs`). `secrets`/`inputs` are **reserved** — parsed as tokens ahead of their resolvers. - `ResolveCtx` with per-namespace lookups. `resolve_with()` fails loudly (`Unavailable`) for a token whose namespace isn't provided in context; `substitute_with()` substitutes provided namespaces and preserves the rest. `resolve()` / `substitute_variables()` are thin wrappers over one core path. - `ResolveEnvError` → `ResolveError { namespace, name, kind: Missing | Unavailable }` (message text unchanged for env/vars; the kind no longer bakes the namespace in, so it scales to four namespaces without an enum explosion). - `Provenance` tracks secret-sourced names alongside env-sourced, for uniform redaction later. - **`as_source()` is clippy-gated** (`disallowed-methods`). It keeps its name; every call site carries an `#[expect(..., reason)]` classifying it (serialization, error display, known-leak-pending-fix, demotion-pending, test). The lint turns the leak surface into a greppable, reasoned work-list and the method stays for its permanent uses (serde round-trip of the unresolved template + diagnostics). - fabro-server: five duplicate `process_env_var` facades and two duplicate `resolve_interp` helpers consolidated into one `crate::interp` module. ## Behavior changes (honest list) - **`{{ secrets.* }}` / `{{ inputs.* }}` are now reserved.** On main they weren't recognized as tokens → silent literal passthrough. Now, at `resolve()` consumers they **fail loud** (`Unavailable`) instead of passing the literal string through (nobody wants the literal characters as a value — strictly better, but technically a change). At `as_source` sites they round-trip unchanged. Actual resolution lands in later enhancing PRs. - Some fabro-server resolution errors gain a `"failed to resolve <source>"` context line. Otherwise behavior-neutral: every field resolves exactly as it did on main. ## What's deferred to follow-up PRs (reduce-first order) - **Reducing / cleanup (next):** demote leak fields to `String` (`run.model.*`, `cli.exec.model.*`, `run.git.author.*`, `run.scm.owner/repository`); de-template `condition`/`label`/`model`/ `provider`/`speed` and `output_schema`. - **Enhancing (after):** resolve `{{ env.* }}` in MCP transports, prepare steps, and hooks; wire `secrets`/`inputs`. ## Verification - `cargo build --workspace` - `cargo nextest run --workspace` → 6449 passed, 181 skipped - `cargo +nightly fmt --check --all` - `cargo +nightly clippy --workspace --all-targets -- -D warnings` → clean ## Reviewer notes - The reserved-namespace `Unavailable` error for `secrets`/`inputs` is **intentional**, not a missing case — they're parsed ahead of their resolvers so misuse fails loud instead of leaking. - `as_source` is clippy-gated but keeps its name deliberately — the gate is the enforcement; renaming was avoided as unnecessary churn. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-10 12:51:08 -04:00
fabro-sh-0530[bot]	4cff07373c	feat: add server-owned environment store (Task 1 & 2 foundation) (#446) ... ## Summary Moves environment definitions out of project/workflow TOML config and into server-owned files, introducing the `fabro-environment` crate and enforcing source-aware validation so project/workflow/user configs can no longer define environment catalogs. ### What changed **New `fabro-environment` crate** — workspace crate wired into `fabro-cli` and `fabro-server`. Exposes a `seeded_catalog_layer()` that CLI commands inject at the call site to fill the environment catalog that settings resolution requires. **Config environments are now migration-only** — `defaults.toml` no longer ships a built-in `[environments.*]` catalog. Instead: - `SettingsSource` enum tags every parsed layer (ActiveSettings, Project, Workflow, DirectRun, User). - `validate_settings_source` rejects `[environments.<id>]` in any source except `ActiveSettings` with a targeted message: `[environments.<id>] is now server-managed; move this definition to the server environments directory`. - TOML-provided `run.environment.{image,resources,network,lifecycle,labels,volumes,env}` overrides are also rejected; only `run.environment.id` survives. **New migration** (`2026052801_settings_environments_to_server_files`) — chains after the existing legacy-sandbox migration. Extracts `[environments.*]` entries from `settings.toml` into sibling `environments/<id>.toml` files, writes a `.settings-environments-migration.bak` backup, and fails without modifying any file if a target already exists. **Builder API additions** — `RunSettingsBuilder::load_from_with_catalog`, `load_default_with_catalog`, `from_toml_with_catalog` let callers inject a server-side catalog; the bare `from_toml` path now errors if no catalog is present and a named environment is selected. `WorkflowSettingsBuilder` test helpers in `src/tests/mod.rs` centralise catalog injection across all config tests. **`.fabro/project.toml`** — removed the inline `[environments.fabro-dev]` block (environment definition now lives server-side). ### Key design decisions - CLI offline commands (graph, preflight, validate) use `seeded_catalog_layer()` as a local stand-in until a running server is available — matches the pre-existing behaviour without regressing offline workflows. - `load_settings_path` no longer runs migrations for non-ActiveSettings sources, preventing project/workflow files from accidentally triggering file-system writes. - The `MigrationReport` type is now the new migration's `SettingsEnvironmentsMigrationReport` (exposes `contents: String` instead of a parsed layer), keeping `load.rs` simpler and decoupled from layer parsing. ### Fabro Details <details> <summary>Ran 9 stages in 143m 23s for $105.27</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 11s | – | 0 | | preflight_lint | 2m 23s | – | 0 | | implement | 28m 27s | – | 0 | | simplify_opus | 37m 27s | $53.28 | 0 | | simplify_gpt | 20m 50s | $12.14 | 0 | | verify | 6m 3s | – | 0 | | fixup | 45m 15s | $39.84 | 0 | | **Total** | **143m 23s** | **$105.27** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: Bryan Helmkamp <bryan@brynary.com>	2026-05-28 17:10:59 -04:00
fabro-sh-0530[bot]	475b4ab650	Replace stdin JSONL control pipe with WebSocket worker control bus (#440) ... ## Summary Workers no longer receive control messages over stdin JSONL. A new `WorkerControlBus` abstraction (backed by `LocalWorkerControlBus` for local/single-node deployments) publishes `WorkerControlEnvelope` messages server-side; a worker-initiated WebSocket at `GET /runs/{id}/worker/control-stream` delivers them with ordered, replayable delivery frames. The bus API is designed so a Redis Streams backend can slot in later without touching API handlers or worker message handling. ### Plan Summary - **Task 1 – Bus contract:** `WorkerControlBus` trait, `WorkerControlDelivery`, `WorkerControlCursor` (`Start` / `After(id)`), bus errors. - **Task 2 – Local backend:** `LocalWorkerControlBus` — in-memory per-run stream, replay from `Start`, reconnect via `After(id)`, 1 024-message trim bound, cleanup on terminal runs. - **Task 3 – Server state:** `Arc<dyn WorkerControlBus>` added to `AppState`; `LocalWorkerControlBus` constructed at startup. - **Task 4 – Protocol extension:** `WorkerControlMessage::RunPause` / `RunUnpause`, `WorkerControlDeliveryFrame`, WebSocket liveness constants (`WORKER_CONTROL_WS_PING_INTERVAL = 15s`, `WORKER_CONTROL_WS_LIVENESS_TIMEOUT = 45s`), close-reason strings. - **Task 5 – Worker message handler:** `apply_worker_control_message` split out; pause/unpause routing; delivery-id dedupe (`AppliedWorkerControlDeliveryIds`, capacity 2 048). - **Task 6 – Worker WebSocket client:** `spawn_worker_control_manager` — HTTP→ws/wss and Unix-socket connection, backoff 100ms→5s, first-connection gate before `operations::start/resume`, ping/pong watchdog, fatal loss wired back to `execute`. - **Task 7 – Server route:** `GET /runs/{id}/worker/control-stream`, worker-only auth via new `RequireWorkerRunScoped` extractor, `Start`/`After` cursor dispatch, 410 on invalid cursor, server-side ping/pong. - **Task 8 – Stdin removal:** `RunAnswerTransport::Subprocess` renamed to `Worker { run_id, bus }`; `pump_worker_control_jsonl` deleted; worker launched with `stdin(Stdio::null())`; pause/unpause transport methods added. - **Tasks 9–10 – E2E & verification:** reconnect, invalid-cursor, cancel-over-WebSocket, and human-interview regression tests; no Redis dependency added. ### Key design decisions **`RunAnswerTransport::Subprocess` → `Worker { run_id, bus }`** — all existing transport methods (`submit`, `cancel_run`, `steer`, `interrupt`, `pair_*`) now call `bus.publish(run_id, envelope)` instead of writing to a channel that fed stdin. The match arms are symmetric, so the diff is mechanical but large. **First-connection gate** — `execute()` calls `control_manager.wait_for_first_connection().await?` before `operations::start` or `operations::resume`. Temporary failures spin with backoff; a fatal invalid-cursor or request-build failure propagates as an error before the workflow starts. **Fatal vs. reconnectable** — HTTP 410 or a WebSocket close with reason `"invalid_cursor"` is fatal (infrastructure failure, not user cancellation). Any other close/error triggers the reconnect loop while the run is non-terminal. **`AutomationStore::load` made synchronous** — startup load now uses `std::fs` under a `clippy::disallowed_methods` exception; async `tokio::fs` is no longer needed for the one-shot directory scan. Invalid automation files now fail loudly instead of being silently skipped. **`canRetry` extended to succeeded runs** — `status.kind === "succeeded"` is now retryable (non-archived). Tests and API docs updated to match. **Default model bumps** — OpenAI default: `gpt-5.4` → `gpt-5.5`; Gemini default: `gemini-3.1-pro-preview` → `gemini-3.5-flash`. ### Fabro Details <details> <summary>Ran 9 stages in 129m 19s for $58.27</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 10s | – | 0 | | preflight_lint | 2m 23s | – | 0 | | implement | 73m 48s | $41.53 | 0 | | simplify_opus | 22m 55s | $11.75 | 0 | | simplify_gpt | 7m 19s | $2.74 | 0 | | verify | 8m 51s | – | 0 | | fixup | 10m 59s | $2.24 | 0 | | **Total** | **129m 19s** | **$58.27** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: Bryan Helmkamp <bryan@brynary.com>	2026-05-27 20:24:25 -04:00
fabro-sh-0530[bot]	7b7a2c9044	Add fabro variable CLI namespace for server-managed variables (#434) ... ## Summary Exposes the existing variables API through a new `fabro variable` CLI namespace (`list`, `get`, `set`, `rm`), following the same patterns as `fabro secret`. Variables are intentionally readable — `list` and `get` show stored values — while `fabro secret` remains write-only. This PR also ships a significant set of accompanying changes: a refactored sandbox lifecycle model in the web UI, removal of the `fabro-devcontainer` crate, and a new `RunSandbox` OpenAPI schema that models the full planned → initializing → ready/failed lifecycle. ## What Changed ### CLI (`fabro variable`) - New `fabro variable` namespace with `list` (aliased `ls`), `get`, `set`, and `rm` subcommands, dispatched through the same `ServerTargetArgs` pattern as `fabro secret`. - `fabro-client` gains five new wrapper methods (`list_variables`, `get_variable`, `create_variable`, `update_variable`, `delete_variable`) over the generated OpenAPI client. - `set` is an upsert; `--value-stdin` accepts empty input after newline-trimming (unlike the secrets equivalent). - CLI reference docs (`docs/public/reference/cli.mdx`) regenerated; `docs/public/workflows/variables.mdx` gains a short section explaining `{{ vars.NAME }}` interpolation and the variables-vs-secrets security boundary. ### Sandbox lifecycle model (web) - New `RunSandbox` OpenAPI shape splits the old flat object into `kind` (planned/initializing/ready/failed) + `plan` + optional `instance` + optional `failure`. - `apps/fabro-web/app/lib/run-sandbox-lifecycle.ts` centralises lifecycle helpers (`sandboxLifecycleKind`, `sandboxInstance`, `sandboxRuntime`, `sandboxIsReady`, `sandboxTabVisible`, `SANDBOX_LIFECYCLE_DISPLAY`). - Run summary panel and sandbox route now show lifecycle state (Initializing / Failed with causes / Not created) before or instead of the fully-loaded `SandboxDetails`. - The sandbox details query is skipped entirely until `sandboxIsReady` returns true, preventing unnecessary 404 fetches for planned/failed sandboxes. - `runHasSandbox` in `tabs-shell.tsx` delegates to `sandboxTabVisible`, hiding the Sandbox tab for `planned` state and showing it for `initializing`/`ready`/`failed`. - Legacy flat sandbox shape (no `kind`) is handled via backwards-compatible shims in the new helpers. ### `fabro-devcontainer` removal - The `fabro-devcontainer` crate has been removed from `Cargo.lock` and all dependent crates. - References to devcontainer in internal plans, docs, changelog entries, and event schemas have been cleaned up or reworded to reflect that the feature is no longer present. ### Plan summary - **Unit 1:** `fabro-client` variable wrappers - **Unit 2:** CLI args, dispatch, and `commands/variable/mod.rs` - **Unit 3:** `list`, `get`, `set`, `rm` behavior modules - **Unit 4:** Test harness helpers and integration tests - **Unit 5:** Regenerated CLI docs + `variables.mdx` update ### Fabro Details <details> <summary>Ran 8 stages in 58m 50s for $23.81</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 9s | – | 0 | | preflight_lint | 2m 21s | – | 0 | | implement | 31m 34s | $18.44 | 0 | | simplify_opus | 8m 48s | $2.60 | 0 | | simplify_gpt | 4m 1s | $2.77 | 0 | | verify | 9m 17s | – | 0 | | **Total** | **58m 50s** | **$23.81** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh>	2026-05-27 13:57:25 -04:00
Bryan Helmkamp	352b7c5de4	refactor: remove devcontainer support (#433) ... ## Summary Remove devcontainer support from the product surface and codebase: the parser crate, workflow bridge, lifecycle execution path, typed events, CLI progress rendering, generated client field, and public/internal documentation references are all gone. ## What Changed - Deleted the dedicated parser crate and removed its Cargo dependencies and lockfile entries. - Removed workflow initialization paths that resolved repository devcontainer metadata, applied Daytona snapshots from it, merged environment variables from it, or ran its lifecycle commands. - Removed the typed event variants and CLI progress handlers for the retired lifecycle events while leaving shared unknown-event handling intact. - Cleaned the generated TypeScript client and tracked docs so repository search has no remaining devcontainer references outside git history. ## Verification - `cargo +nightly-2026-04-14 fmt --all` - `cargo +nightly-2026-04-14 fmt --check --all` - `cargo build --workspace` - `cargo nextest run -p fabro-types` - `cargo nextest run -p fabro-workflow` - `cargo nextest run -p fabro-cli run_progress` - `cd lib/packages/fabro-api-client && bun run generate && bun run typecheck` - `cargo metadata --no-deps --format-version 1 | rg -i "fabro-devcontainer|devcontainer"` - `rg -n -i "devcontainer|dev container|dev-container|dev_container|fabro-devcontainer|\\.devcontainer" . --glob '!target/**' --glob '!.worktrees/**'` --- [](https://github.com/EveryInc/compound-engineering-plugin) 🤖 Generated with GPT-5 via [Codex](https://openai.com/codex)	2026-05-27 12:48:40 -04:00
Bryan Helmkamp	e13de9faaf	feat(automation): persist automation refs on runs (#428) ... ## Summary Adds durable automation metadata to workflow runs so automation-triggered runs can carry their automation and trigger references through creation, stored events, projections, summaries, fork, retry, and API surfaces. This also introduces the new `fabro-automation` crate with typed automation IDs, TOML parsing/validation, revision hashing, and a file-backed automation store. The store avoids overwriting malformed existing TOML files on create and keeps read access from being blocked by mutation disk I/O. ## Changes - Add `AutomationRef` propagation through `RunSpec`, `run.created`, store projections, summaries, fork, retry, and related tests. - Add `fabro-automation` domain/store crate for automation TOML definitions, trigger validation, revisions, create/replace/delete, and load behavior. - Update OpenAPI and regenerated TypeScript client types for `RunSpec.automation` and `AutomationRef.trigger_id`. - Add API/type regression coverage for the new automation fields. - Harden automation store create semantics so skipped malformed files still reserve their path. ## Verification - `cargo nextest run -p fabro-automation` - `cargo +nightly-2026-04-14 clippy -p fabro-automation --all-targets -- -D warnings` - `cargo nextest run -p fabro-api` - `cargo nextest run -p fabro-types run_spec_round_trips_templated_settings run_created_props_round_trip_templated_settings` - `cd lib/packages/fabro-api-client && bun run typecheck` - `cargo +nightly-2026-04-14 fmt --check --all` - `git diff --check`	2026-05-27 11:52:57 -04:00
Bryan Helmkamp	ec1b3f2084	feat(sandbox): secure daytona snapshot names (#429) ... ## Summary Secures Daytona custom snapshot creation by removing user-controlled snapshot/image references and replacing them with deterministic names Fabro computes internally. Docker image selection now uses `image.docker`, while Daytona only accepts `image.dockerfile` for custom snapshots and continues to use `daytona-medium` when no Dockerfile is configured. ## Changes - Replaces public `image.ref` config/API shape with Docker-specific `image.docker` across Rust settings, OpenAPI, generated TypeScript client, docs, defaults, examples, and web samples. - Adds Daytona snapshot identity generation using HMAC-SHA256 over a canonical manifest keyed by the Daytona API key, producing `fabro-<uuid>` snapshot names without exposing Dockerfile text or key material. - Routes Daytona custom Dockerfiles, including devcontainer-generated Dockerfiles, through the same computed identity path before calling Daytona snapshot APIs. - Updates sandbox initialization events and store projections so initialized run state can show the resolved image and computed Daytona snapshot after startup. - Updates legacy config migration behavior so Docker image refs map to `image.docker`, while Daytona legacy snapshot names are not preserved. ## Breaking Changes - `image.ref` is no longer accepted in new environment config. - Docker environments should use `image.docker` for image selection. - Daytona environments reject `image.docker`; use `image.dockerfile` to request a custom computed snapshot. ## Verification - `cargo build -p fabro-api` - `cd lib/packages/fabro-api-client && bun run generate` - `cd lib/packages/fabro-api-client && bun run typecheck` - `cd apps/fabro-web && bun run typecheck` - `cargo +nightly-2026-04-14 fmt --check --all` - `cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings` - `ulimit -n 4096 && cargo nextest run --no-fail-fast -p fabro-cli -p fabro-config -p fabro-sandbox -p fabro-workflow -p fabro-store -p fabro-server -p fabro-api` - `cargo insta pending-snapshots` --- [](https://github.com/EveryInc/compound-engineering-plugin) 🤖 Generated with GPT-5 via [Codex](https://openai.com/codex)	2026-05-27 11:52:35 -04:00
fabro-sh-0530[bot]	5d6cd48e9e	Replace vague expect/panic messages with invariant-explaining messages (#422) ... Production code must not panic without a clear explanation of *why* the failure is impossible. This PR upgrades panic-adjacent messages across the codebase to meet that standard, and converts two genuine runtime panics into proper error handling. ## What changed **Invariant-explaining `expect` messages** — all existing `expect("short label")` calls that guarded hard-coded literals, just-inserted map entries, just-pushed Vec elements, or hard-coded regex/template strings now carry a sentence explaining *why* the None/Err path cannot be reached (e.g. `"node was just inserted by ensure_node, so get_mut cannot return None"`). No behavior changes. **`assert_eq!` → `panic!` with justification** in `strategy.rs` — the bare assert is replaced with an explicit `panic!` whose message names every existing call site that enforces the `CodexDevice ↔ OpenAI` invariant, making future regressions easier to diagnose. **Genuine runtime errors converted to `Result`** — `select_backend` / `select_backend_for_gh_command` in the upgrade command previously called `.expect()` on `http_client()`, which can fail due to TLS or environment issues. Both functions now return `Result<Backend>` and propagate the error to the CLI boundary. **Signal handler panics degraded to warnings** in `serve.rs` — `ctrl_c()` and `unix::signal()` failures no longer panic the server; instead they log a warning and park the future, allowing the server to keep running without graceful-shutdown support rather than crashing on startup. **Telemetry thread spawn failure** in `fabro-telemetry` — instead of panicking, a failure to spawn the background thread logs a debug message and silently disables telemetry, which is the correct degradation for an optional observability feature. **OS RNG `expect` messages** — three sites (`random_secret`, `random_auth_code`, `generate_dev_token`) now explain that a failure means the system RNG is broken and the security of the generated value would be compromised, justifying the panic boundary. ### Fabro Details <details> <summary>Ran 3 stages in 45m 16s for $11.65</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | work | 34m 22s | $9.00 | 0 | | audit | 10m 35s | $2.65 | 0 | | **Total** | **45m 16s** | **$11.65** | **0** | </details> <details> <summary>Ran <code>Goal.fabro</code> (4 nodes and 5 edges)</summary> ```dot digraph Goal { graph [ goal="Complete the user-provided goal", rankdir=LR, max_node_visits=30 ] start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] work [ label="Work", thread_id="goal", fidelity="full", max_visits=12, prompt="@prompts/continue.md" ] audit [ label="Completion Audit", thread_id="goal", fidelity="full", goal_gate=true, retry_target="work", output_schema="routing", output_retries=2, max_visits=12, prompt="@prompts/audit.md" ] start -> work -> audit audit -> exit [label="Done", condition="outcome=succeeded"] audit -> work [label="Continue", condition="outcome=failed || preferred_label=Continue"] audit -> work [label="No clear verdict"] } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: Bryan Helmkamp <bryan@brynary.com>	2026-05-27 10:38:20 -04:00
fabro-sh-0530[bot]	01892185ff	Replace bare unwrap() with documented expect() across production runtim… (#415) ... Audit and remediation pass enforcing the project's no-panic-in-production policy. Every `unwrap()` on a mutex/RwLock in reachable runtime code is replaced with `expect()` carrying a message that explains *why* the lock cannot be poisoned (no code panics while holding it). Bare `unreachable!()` and `panic!()` calls are updated with messages that name the invariant being asserted. One genuine bug is fixed in the process. ## What changed **`unwrap()` → `expect()` on locks** (`fabro-core`, `fabro-oauth`, `fabro-util`, `fabro-workflow/*`, `fabro-server`): Every `Mutex`/`RwLock` `.unwrap()` in production paths now carries the standard justification pattern: `"<name> mutex/RwLock should not be poisoned: no code panics while holding this lock"`. **`unreachable!()` and `panic!()` message quality**: Bare `unreachable!()` calls in `subagent.rs`, `wait.rs`, `condition.rs`, `event/convert.rs`, and `server.rs` now name the structural invariant (e.g. "outer match arm already verified…"). The `panic!` in `tools.rs` now includes the offending name and the expected format, making it actionable. **`sha_newtype` / `short_sha_newtype` in `run_files.rs` — actual bug fix**: These helpers previously called `unwrap_or_else(|e| panic!(…))` on git output, meaning a malformed SHA from a real git subprocess would panic in a request handler. They now return `Result<T, ApiError>` and propagate errors to callers, which in turn propagate with `?`. This is the only change that alters observable behavior under failure. **Demo-only panics in `fabro-server/src/demo/mod.rs`**: Panic messages updated to clarify that these paths operate on hardcoded compile-time constants, so the panic is a programming-error guard rather than a runtime failure guard. ## Design note The lock-poisoning `expect` messages all follow a single template so reviewers can quickly verify the claim: if you ever add code that can panic inside a lock guard scope, the message becomes a lie and that must be caught in review. The uniformity is intentional. ### Fabro Details <details> <summary>Ran 0 stages in 64m 54s for $14.28</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | **Total** | **64m 54s** | **$14.28** | **0** | </details> <details> <summary>Ran <code>Goal.fabro</code> (4 nodes and 5 edges)</summary> ```dot digraph Goal { graph [ goal="Complete the user-provided goal", rankdir=LR, max_node_visits=30 ] start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] work [ label="Work", thread_id="goal", fidelity="full", max_visits=12, prompt="@prompts/continue.md" ] audit [ label="Completion Audit", thread_id="goal", fidelity="full", goal_gate=true, retry_target="work", output_schema="routing", output_retries=2, max_visits=12, prompt="@prompts/audit.md" ] start -> work -> audit audit -> exit [label="Done", condition="outcome=succeeded"] audit -> work [label="Continue", condition="outcome=failed || preferred_label=Continue"] audit -> work [label="No clear verdict"] } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: Bryan Helmkamp <bryan@brynary.com>	2026-05-26 17:46:39 -04:00
fabro-sh-0530[bot]	bd72570437	Add provider-backed sandbox inventory API and rename SandboxProvider to… (#409) ... ## Summary Exposes `GET /api/v1/sandboxes` and `GET /api/v1/sandboxes/{id}` endpoints that query sandbox inventory directly from configured providers (Docker, Daytona), independent of run projections. Also renames the existing `SandboxProvider` enum to `SandboxProviderKind` throughout the codebase to free the name for the new `SandboxProvider` trait. ### Plan Summary - **OpenAPI + types**: New `SandboxInfo`, `SandboxListResponse`, `SandboxListMeta`, `SandboxProviderLookupError`, and `SandboxProviderKind` schemas added to the API spec; canonical Rust DTOs added to `fabro-types`. - **Provider trait and registry**: `SandboxProvider` trait (`list`, `get`, `create`, `delete`) and `SandboxProviderRegistry` introduced in `fabro-sandbox/src/provider.rs`. Registry fans out calls across all configured providers and implements fail-soft semantics for list and conflict/unavailable detection for get. - **Provider implementations**: `DockerSandboxProvider` uses Bollard label-filtered container listing and per-inspect; `DaytonaSandboxProvider` uses the SDK with paginated label-filtered listing. Both verify `sh.fabro.managed=true`. - **Shared detail mapping**: Docker and Daytona inspect-to-`SandboxInfo` paths extracted into `docker_info_from_inspect` / `daytona_info_from_sdk_sandbox` so run-scoped `SandboxDetails` and inventory `SandboxInfo` share the same normalization logic. - **Monitoring UI**: `RunsInfo` now exposes `scheduler_slots_used`; the monitoring panel displays "slots used" instead of the raw active-run count. ## What changed and why **`SandboxProvider` → `SandboxProviderKind`** is a mechanical rename across ~20 call sites so the unqualified name `SandboxProvider` can be claimed by the new trait without collision. **Registry lookup semantics** for `get_managed_by_native_id`: | Outcome | HTTP | |---|---| | Exactly one provider matches | `200` | | All providers succeed, none match | `404` | | Two or more providers match the same id | `409` | | No match + at least one provider failed | `502` | List is always fail-soft: partial results are returned and failing providers appear in `meta.provider_errors`. **`DockerFields` / `DaytonaFields` structs** were introduced inside `details.rs` to hold the shared normalization output. Both `map_docker_inspect` (run-scoped) and `docker_info_from_inspect` (inventory) now delegate to `docker_fields_from_inspect`, eliminating duplicate field-extraction logic. Same pattern for Daytona. **`futures` moved from optional to unconditional** in `fabro-sandbox/Cargo.toml` because `join_all` / `try_join_all` are now used in `provider.rs`, which is not feature-gated. **`local` provider** intentionally returns an empty list and `None` for get — it has no provider-managed inventory. ### Fabro Details <details> <summary>Ran 8 stages in 102m 54s for $41.81</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 6s | – | 0 | | preflight_lint | 2m 20s | – | 0 | | implement | 56m 40s | $10.82 | 0 | | simplify_opus | 27m 50s | $26.24 | 0 | | simplify_gpt | 5m 2s | $4.76 | 0 | | verify | 8m 24s | – | 0 | | **Total** | **102m 54s** | **$41.81** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh>	2026-05-25 22:41:57 -04:00
fabro-sh-0530[bot]	e8f0aceee8	refactor: rationalize server secret scopes (vault-only for optional int… (#401) ... ## Summary Separates Fabro server secrets into two explicit scopes: **bootstrap** secrets that come from process env or `server.env`, and **optional integration** secrets that come exclusively from the vault. This makes secret resolution simple and predictable, and removes all `process env → server.env` fallback paths for optional integrations such as GitHub App, Slack, Daytona, Brave Search, and LLM provider keys. ## What changed **New `ToolSecrets` struct in `fabro-agent`** — Brave Search API key is now passed explicitly through `SessionOptions.tool_secrets` rather than read from process env inside the tool. The standalone CLI reads the key at the CLI boundary (with an explicit `#[expect(clippy::disallowed_methods)]` annotation); the server will read it from the vault. The error message changes from `"BRAVE_SEARCH_API_KEY environment variable is not set"` to `"BRAVE_SEARCH_API_KEY is not configured"`. **`VaultCredentialSource::vault_only` constructor in `fabro-auth`** — Adds a constructor that passes `|_| None` as the env lookup, ensuring the server LLM credential source never resolves provider keys from process env. **GitHub App secrets move to vault in install flows** — Both the CLI `fabro install github` path and the browser install finish handler now write `GITHUB_APP_PRIVATE_KEY`, `GITHUB_APP_CLIENT_SECRET`, and `GITHUB_APP_WEBHOOK_SECRET` to the vault instead of `server.env`. Switching strategies removes stale secrets from the other strategy's storage location. The `vault_set` field type changes from `Vec<(String, String)>` to `Vec<VaultSecretWrite>` to carry per-secret type metadata (file vs. token). **`fabro-vault` gains a `fabro-static` dependency** — Needed so the vault crate can reference canonical env-var names from the shared registry without a cycle. **`GH_TOKEN` fallback removed** — `GITHUB_TOKEN` is now read from the vault only; the changelog and `server-configuration.mdx` note drops mention of `GH_TOKEN` as an accepted fallback. **Version bump** — Workspace crates promoted from `0.244.0-nightly.0` to `0.244.0`. **Docs** — Internal strategy doc, public admin docs (Docker, Railway, server-configuration, security, troubleshooting), and integration docs (GitHub, Slack, Daytona, Brave Search, LiteLLM, tools reference, models) all updated to reflect vault-only optional secrets and direct users to `fabro secret set` rather than process env or `server.env`. ### Plan Summary - **Task 1** (secret registry) — not yet present in this diff; classification lives in the places that consume it. - **Task 3–6** (vault-only lookups for GitHub, Slack, Daytona, LLM) — implemented via `vault_only` constructor, `tool_secrets` threading, and install-path changes. - **Task 7** (Brave Search explicit injection) — `ToolSecrets`, `register_core_tools` wiring, CLI boundary read. - **Task 8** (install persistence) — GitHub App secrets written to vault; token strategy writes `GITHUB_TOKEN` to vault and clears app vault keys; app strategy clears `GITHUB_TOKEN` vault key. - **Task 9** (docs) — all public and internal docs updated. ### Fabro Details <details> <summary>Ran 0 stages in 155m 26s for $60.85</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | **Total** | **155m 26s** | **$60.85** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: Bryan Helmkamp <bryan@brynary.com>	2026-05-25 17:26:01 -04:00
fabro-sh-0530[bot]	b15d8b8476	feat: Add approve/deny run controls to MCP and CLI (#400) ... ## Summary Exposes the existing `POST /api/v1/runs/{id}/approve` and `POST /api/v1/runs/{id}/deny` REST endpoints through the `fabro_run_interact` MCP tool and two new top-level CLI commands (`fabro approve`, `fabro deny`). Workflow agents are explicitly blocked from using these actions — approval remains a human/user operation. ## What changed **Client & tool backend** (`fabro-client`, `fabro-tool`): Added `approve_run` and `deny_run` to `Client` and the `FabroToolBackend` trait, implemented in `ClientBackend`. `deny_run` passes a `DenyRunRequest` body; absent, blank, or whitespace-only reasons are normalised to `None`. **`fabro_run_interact` MCP tool**: Added `Approve` and `Deny` variants to `RunInteractAction` / `ValidatedInteractAction`, and an optional `reason` parameter (only valid for `deny`; validated and trimmed on input). Both actions return `{ "summary": … }` using the existing shape. The tool description is updated to list the new actions. **Workflow-agent guard** (`fabro-workflow`): Before dispatching `fabro_run_interact`, the handler checks `validated.action.requires_user()`. If the action is `approve` or `deny`, it returns an immediate `ToolError` without ever reaching the backend, keeping the guard explicit and independent of server auth. **CLI** (`fabro-cli`): Extracted the archive/unarchive batch loop into a shared `run_resolved_run_batch` helper in `commands/runs/mod.rs`, then implemented `approval.rs` using the same helper. Both commands follow the same batch contract as archive: attempt all runs, collect per-run errors, exit non-zero if any fail, and emit `{ "approved"/"denied": […], "errors": […] }` in JSON mode. **Server auth regression** (`fabro-server`): Extended `run_tools_worker_cannot_call_user_only_non_mcp_routes` to cover `POST /runs/{id}/deny` alongside the existing `approve` and `timeline` checks. **Docs** (`mcp.mdx`, `cli.mdx`): Updated the `fabro_run_interact` table entry and added approve/deny examples, plus reference sections for the two new CLI commands. ### Plan Summary - Add `approve_run` / `deny_run` to `Client` and `FabroToolBackend` - Extend `fabro_run_interact` with `approve`, `deny`, and optional `reason` - Block workflow-agent self-approval with an early `ToolError` - Refactor archive batch loop into shared `run_resolved_run_batch` helper - Add `fabro approve` and `fabro deny` CLI commands reusing that helper - Add integration tests for CLI commands, MCP tool, and server auth guard ### Fabro Details <details> <summary>Ran 9 stages in 63m 57s for $42.33</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 6s | – | 0 | | preflight_lint | 2m 17s | – | 0 | | implement | 28m 16s | $32.57 | 0 | | simplify_opus | 10m 59s | $4.24 | 0 | | simplify_gpt | 6m 13s | $3.96 | 0 | | verify | 10m 51s | – | 0 | | fixup | 2m 29s | $1.55 | 0 | | **Total** | **63m 57s** | **$42.33** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh>	2026-05-25 15:49:57 -04:00
Bryan Helmkamp	245052db38	feat(cli): allow rendering invalid graphs ... Keep graph validation diagnostics visible, but let users opt into rendering DOT workflows that fail semantic validation with --allow-invalid.	2026-05-25 10:19:32 -04:00
fabro-sh-0530[bot]	98c26d5370	Fold context-window data into agent.message, remove snapshot event (#390) ... ## Summary Removes the standalone `agent.context_window.snapshot` event and instead attaches the context-window projection directly to `agent.message`. This eliminates the async provider token-count API calls that the old approach required, and simplifies the event log to a single event type carrying all post-response agent data. ## What Changed and Why **Before:** After each LLM turn, the agent emitted a separate `agent.context_window.snapshot` event — first a local estimate, then potentially a second one after an async `count_input_tokens` call resolved (or after response usage arrived). This required fingerprint deduplication state, a `close_token` to cancel in-flight counts, and frontend handling for the extra event type. **After:** The `AgentEvent::AssistantMessage` variant carries an `Option<StageContextWindowProjection>`. The projection is computed locally at request-build time and then refined using response token usage when available (`ResponseUsageScaledBreakdown`), or kept as a `LocalEstimate` when response usage is absent. No provider API calls are made. ### Plan Summary - **Task 1:** Added `context_window: Option<StageContextWindowProjection>` to `AgentMessageProps` (Rust types + OpenAPI), removed `AgentContextWindowSnapshotProps` and `EventBody::AgentContextWindowSnapshot`. - **Task 2:** Removed the spawned `count_input_tokens` task, `close_token`, fingerprint sets, and both snapshot-emit methods from `Session`. Added `context_window_from_response_usage` to `context_window.rs`; `BuiltRequest` now holds the local projection instead of the tool list. - **Task 3:** Workflow conversion copies `context_window` from `AgentEvent::AssistantMessage` into `AgentMessageProps`; store reducer reads it from `AgentMessage` instead of the removed snapshot variant and stamps `event_seq`. - **Task 4:** GET endpoint tests updated to seed data via `agent.message` with embedded context-window; endpoint behavior unchanged. - **Task 5:** Frontend constant and tests for `agent.context_window.snapshot` removed; `agent.message` already invalidates `stageContextWindow` through existing stage-activity handling. TypeScript client regenerated with the new `AgentMessageProps` model. ### Key Design Decisions - **No provider token-count API calls** during normal execution — context-window accuracy relies on local estimates scaled by response usage, which is always available for successful turns. - **Failed-before-response turns** emit no context-window data (`context_window: None`), matching the old behavior where a snapshot would have been emitted but response-usage scaling would never arrive. - `BuiltRequest` drops the `tools` field (only needed for the now-removed snapshot emission path); the local projection is computed at build time and stored directly. ### Fabro Details <details> <summary>Ran 8 stages in 60m 3s for $55.78</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 1s | – | 0 | | preflight_lint | 2m 16s | – | 0 | | implement | 30m 39s | $44.82 | 0 | | simplify_opus | 10m 48s | $4.03 | 0 | | simplify_gpt | 5m 1s | $6.93 | 0 | | verify | 8m 47s | – | 0 | | **Total** | **60m 3s** | **$55.78** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: Bryan Helmkamp <bryan@brynary.com>	2026-05-24 15:48:21 -04:00
Bryan Helmkamp	e1ea4ebb9d	Fix verification fixture drift	2026-05-24 12:14:59 -04:00
fabro-sh-0530[bot]	dbe3e3966d	Migrate sandbox config to named environments; add InterviewOption metad… (#372) ... ## Summary Two related changes land together: the sandbox configuration surface is replaced with a named-environment model, and `InterviewOption` gains `description` and `preview` fields needed for the mid-stage agent interview tools described in the plan. ## What changed ### Named environments (was `[run.sandbox]`) `[run.sandbox]` and its provider-specific sub-tables (`[run.sandbox.daytona]`, `[run.sandbox.docker]`) are replaced by a two-level model: - **`[environments.<slug>]`** — reusable catalog entries with a unified shape: `provider`, `image`, `resources`, `network`, `lifecycle`, `labels`, `volumes`, `env`. - **`[run.environment] id = "<slug>"`** — selects which environment a run uses. - **`[run.environment.<field>]`** — sparse run-level overrides applied on top of the selected environment. The OpenAPI schema drops `RunSandboxSettings`, `DaytonaSettings`, `DaytonaSnapshotSettings`, `DaytonaNetworkLayer`, and `DockerSettings` in favour of `EnvironmentSettings`, `RunEnvironmentSettings`, and the new sub-schemas (`EnvironmentImageSettings`, `EnvironmentResourcesSettings`, `EnvironmentNetworkSettings`, `EnvironmentLifecycleSettings`, `EnvironmentVolumeSettings`). The `--sandbox` CLI flag becomes `--environment`. All docs, example configs, `.fabro/project.toml`, and the automation-detail / run-settings UI panels are updated to the new shape. The run-settings page renames "Sandbox" → "Environment" and reads from the new field paths. ### `InterviewOption` metadata fields `description` and `preview` are added to the canonical `InterviewOption` type (OpenAPI, helpers.ts, interview-dock, human-qa renderer). Both are treated as untrusted model-authored text — stored and displayed as plain strings, never rendered as HTML. The `interview-dock` test asserts that raw HTML in `preview` is not rendered. Option `description` is shown as secondary text under the label in choice and multi-select buttons. ### `StageModelUsage` projection `provider_used` on `RunStageInfo` and stage projections is promoted from a freeform object to a typed `StageModelUsage` schema (with `mode`, `provider`, `model`, `reasoning_effort`, `speed`). The `extractStageModel` event-scraping helper is replaced by `formatStageModelUsageLabel` and `stageModelUsageTitle`, which work directly from the projection field. The `Stage` interface gains `providerUsed` and the `EventsToolbar` consumes it. ### Other schema additions `ReasoningEffort` enum, `small_default` on model info, `SubAgentProjection`/`SkillsProjection`/`McpServerProjection` inline in stage projections, and `TodoListProjection` moved from the run-state top-level `todos_by_list` map into per-stage `todos`. ### Plan summary - Replace `[run.sandbox]` config with `[environments.<slug>]` + `[run.environment]` selection across config, OpenAPI, UI, and docs. - Extend `InterviewOption` with `description` and `preview`; render `description` in choice/multi-select buttons. - Promote `provider_used` to a typed `StageModelUsage` schema; drop event-scraping in favour of the projection field. - Add `ReasoningEffort`, `small_default`, subagent/skills/MCP stage-projection schemas to OpenAPI. ### Fabro Details <details> <summary>Ran 9 stages in 93m 2s for $48.56</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 4s | – | 0 | | preflight_lint | 2m 16s | – | 0 | | implement | 39m 28s | $35.95 | 0 | | simplify_opus | 22m 6s | $8.66 | 0 | | simplify_gpt | 7m 18s | $1.66 | 0 | | verify | 6m 33s | – | 0 | | fixup | 12m 34s | $2.29 | 0 | | **Total** | **93m 2s** | **$48.56** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: Fabro <fabro@fabro.sh> Co-authored-by: Bryan Helmkamp <bryan@brynary.com>	2026-05-23 15:47:33 -04:00
fabro-sh-0530[bot]	f73f2a53f3	Replace queued with pending/runnable and add approval flow (web + API s… (#371) ... ## Summary Replaces the single `queued` pre-execution state with explicit `pending` and `runnable` states, and wires approve/deny actions for parent-generated child runs that require human approval before they can execute. This diff covers the web UI and OpenAPI spec layers of that change. ## What changed **Run status model** - `queued` is removed from all TypeScript types, display maps, column routing, and tests. - `pending` (awaiting approval) and `runnable` (eligible for the scheduler) replace it as distinct board columns and `RunStatus` variants with their own labels and colors (`runnable` gets cyan; `pending` stays muted). **Approval actions** - New `approveRun` / `denyRun` API calls in `run-actions.ts` invoke the new `POST /runs/{id}/approve` and `POST /runs/{id}/deny` endpoints. - `canApprove` predicate requires both `status.kind === "pending"` and `lifecycle.approval?.state === "pending"` — a run whose status is pending but has no approval record does not expose the action. - `useApproveRun` / `useDenyRun` mutations in `mutations.ts` follow the same pattern as `useCancelRun`. - `ActionsMenu` in `run-detail.tsx` gains Approve (lifecycle group) and Deny (destructive group) menu items. **Board and event plumbing** - `columnForStatus` now routes `pending → pending column` and `runnable → runnable column`; `submitted` stays in the pending column. - `BOARD_STATUS_EVENTS` and `RUN_SUMMARY_EVENTS` replace `run.queued` with `run.start_requested`, `run.pending`, `run.approved`, `run.denied`, and `run.runnable`. - The `pending` column is hidden when empty (same behaviour the old `queued` column had). **Waterfall phases (`run-phases.ts`)** - `queued` phase is removed; `pending` and `runnable` phases are added in order. - The submitted phase closes at `run.start_requested` rather than `run.queued`. - Each phase derives its timestamps from its own event rather than a single `firstTs` lookup, making multi-phase pre-execution timelines accurate. **OpenAPI spec** - `POST /api/v1/runs/{id}/approve` and `POST /api/v1/runs/{id}/deny` endpoints added with 200/404/409 responses. - `startRun` description updated to describe the pending/runnable branching behaviour. - `cancelRun` description updated to reference `pending`/`runnable` instead of `queued`. ### Plan Summary - **Task 3** (OpenAPI schema additions for approve/deny endpoints) — complete in this diff. - **Task 6** (Web UI surfaces: board columns, run-detail actions, waterfall phases, event subscriptions) — complete in this diff. - **Task 7** (doc cleanup: references to `queued` replaced in plans, brainstorms, and QA docs) — complete in this diff. ### Fabro Details <details> <summary>Ran 9 stages in 127m 37s for $104.98</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 2s | – | 0 | | preflight_compile | 2m 15s | – | 0 | | preflight_lint | 2m 29s | – | 0 | | implement | 92m 10s | $91.53 | 0 | | simplify_opus | 18m 35s | $10.65 | 0 | | simplify_gpt | 7m 36s | $2.81 | 0 | | verify | 3m 42s | – | 0 | | fmt | 3s | – | 0 | | **Total** | **127m 37s** | **$104.98** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (12 nodes and 15 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --cargo-quiet --workspace --status-level fail 2>&1 && cargo dev docs refresh 2>&1 && cargo dev docs check 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all clippy lint warnings, test failures, and generated docs errors.", max_visits=3] fmt [label="Format", shape=parallelogram, script="cargo +nightly-2026-04-14 fmt --all 2>&1", max_retries=0] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> fmt [condition="outcome=succeeded"] verify -> fixup fixup -> verify fmt -> exit } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: fabro <fabro@anthropic.com> Co-authored-by: Bryan Helmkamp <bryan@brynary.com>	2026-05-23 15:34:33 -04:00
fabro-sh-0530[bot]	0f36304d2c	Add small_default model role and async generated run titles (#368) ... ## Summary Introduces a `small_default` catalog role for identifying each provider's small/cheap utility model, and uses that model to asynchronously generate human-readable run titles when the caller doesn't supply one explicitly. ### Plan Summary - **Catalog**: Add `small_default: Option<bool>` to `ModelCatalogSettings` and `small_default: bool` to the `Model` type. Mark built-in small defaults: `claude-haiku-4-5` (Anthropic), `gpt-5.4-mini` (OpenAI), `gemini-3.1-flash-lite-preview` (Gemini). Validate that each provider has at most one small default; zero is allowed with fallback to the provider's regular default. - **Helpers**: Add `small_default_for_provider` and `small_default_for_configured_ids` on `Catalog`, mirroring the existing `default_for_provider` / `default_for_configured_ids` / `probe_for_provider` pattern. - **Title generation**: New `run_title_generation` module in `fabro-server` builds a prompt from workflow identity, goal, and raw run inputs, calls `generate_object` with `max_tokens(64)` and a 10 s timeout, normalizes output (trim, reject blank/control, truncate to 100 chars), and falls back to the deterministic title on any failure. - **Server integration**: In the create-run handler, if no explicit `RunManifest.title` was supplied and at least one LLM provider is ready, spawn a detached task that generates a title and appends `run.title.updated` — but only if the title hasn't been changed by a concurrent user PATCH. ## What changed and why **`small_default` vs `default`** — the existing `default` role drives normal model selection for workflow execution and must not be disturbed. `small_default` is a separate, additive role for lightweight metadata work. The two roles are intentionally independent so teams can promote a newer large model to `default` without accidentally routing title generation there. **Best-effort, async title enrichment** — run creation is kept synchronous and reliable. The title task is fire-and-forget: LLM errors, timeouts, and validation failures all silently leave the deterministic title in place. The stale-title guard (`current.title != deterministic_title`) prevents the async task from clobbering a concurrent user edit via `PATCH /runs/{id}`. **No redaction** — per the design goal, raw input values are forwarded to the model. This is noted explicitly in the prompt and in the module docs. **Prompt size bounding** — each of the three prompt sections (workflow identity, run inputs, workflow summary) is independently capped at 4 000 characters with a `...[truncated]` marker so pathological inputs can't produce enormous requests. ## Public interface changes - `Model` gains `small_default: bool` in the Rust type, OpenAPI schema, and generated TypeScript client. - `MAX_RUN_TITLE_CHARS` is now `pub` in `fabro-types` so the title-generation module can reuse the same limit. - Config docs (`models.mdx`, `litellm.mdx`) document `small_default = true` alongside `default` and `probe`. ### Fabro Details <details> <summary>Ran 9 stages in 61m 23s for $32.17</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 2s | – | 0 | | preflight_compile | 1m 52s | – | 0 | | preflight_lint | 2m 5s | – | 0 | | implement | 29m 16s | $23.26 | 0 | | simplify_opus | 17m 15s | $6.28 | 0 | | simplify_gpt | 7m 1s | $2.63 | 0 | | verify | 3m 7s | – | 0 | | fmt | 3s | – | 0 | | **Total** | **61m 23s** | **$32.17** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (12 nodes and 15 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --cargo-quiet --workspace --status-level fail 2>&1 && cargo dev docs refresh 2>&1 && cargo dev docs check 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all clippy lint warnings, test failures, and generated docs errors.", max_visits=3] fmt [label="Format", shape=parallelogram, script="cargo +nightly-2026-04-14 fmt --all 2>&1", max_retries=0] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> fmt [condition="outcome=succeeded"] verify -> fixup fixup -> verify fmt -> exit } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: Bryan Helmkamp <bryan@brynary.com>	2026-05-23 13:48:39 -04:00
fabro-sh-0530[bot]	7f84ac5e3f	Replace run-scoped sandbox config with named environments (#360) ... ## Summary Replaces the `[run.sandbox]` configuration surface with a named, provider-explicit environment catalog. Runs now select an environment by slug (`[run.environment] id = "..."`) rather than configuring a sandbox inline. Fabro resolves the catalog through normal settings precedence, applies sparse run-level overrides, and creates a concrete sandbox from the resolved environment. This is a clean break — no `[run.sandbox]` compatibility layer. ### Plan Summary - **New config shape:** Top-level `[environments.<slug>]` catalog valid in `settings.toml`, `.fabro/project.toml`, and `workflow.toml`. Runs reference a slug via `[run.environment] id = "..."` with optional sparse overrides under `[run.environment.*]`. - **Unified environment fields:** `provider`, `image` (ref + dockerfile), `resources` (cpu/memory/disk), `network` (mode + allow CIDRs), `lifecycle` (preserve/stop_on_terminal/auto_stop), `labels`, `volumes`, `env` — replacing the previous split between `[run.sandbox]`, `[run.sandbox.docker]`, `[run.sandbox.daytona]`, and `[run.sandbox.daytona.snapshot]`. - **OpenAPI schema update:** `RunSandboxSettings`, `DockerSettings`, `DaytonaSettings`, and `DaytonaNetworkLayer` replaced with `RunEnvironmentSettings`, `EnvironmentSettings`, `EnvironmentProvider`, `EnvironmentImageSettings`, `EnvironmentResourcesSettings`, `EnvironmentNetworkSettings`, `EnvironmentLifecycleSettings`, and `EnvironmentVolumeSettings`. - **CLI flag rename:** `--sandbox <provider>` → `--environment <slug>` on `run`, `create`, `preflight`, and `server start/restart`. - **Provider capability model:** Hard errors for security properties a provider cannot enforce (local with blocked/CIDR networking; docker with CIDR allow-lists). Warnings for unsupported resource limits, volumes, labels, auto-stop, and Docker Dockerfiles. - **Docs and internal code updated** throughout: `.fabro/project.toml`, workflow configs, all public docs, CLI args, manifest builders, and the runner's GitHub credentials check. ### Provider mapping | Environment field | Local | Docker | Daytona | |---|---|---|---| | `image.ref` | Ignored | Docker image | Snapshot name | | `image.dockerfile` | Ignored | Warning; ignored | Snapshot Dockerfile (requires `image.ref`) | | `resources.cpu/memory/disk` | Warning; ignored | cpu_quota / memory limit / warning | Snapshot sizing | | `network.mode = block` | **Error** | `network_mode = none` | Daytona block | | `network.mode = cidr_allow_list` | **Error** | **Error** | Daytona CIDR allow-list | | `labels` | Warning; ignored | Warning; ignored | Daytona labels | | `volumes` | Warning; ignored | Warning; ignored | Daytona volume mounts | | `lifecycle.auto_stop` | Warning; ignored | Warning; ignored | Daytona auto-stop interval | | `env` | Process env overlay | Container env | Sandbox env | ### Fabro Details <details> <summary>Ran 11 stages in 217m 39s for $129.86</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 4m 7s | – | 0 | | preflight_lint | 4m 9s | – | 0 | | fix_lints | 3m 46s | $1.06 | 0 | | implement | 76m 6s | $57.39 | 0 | | simplify_opus | 71m 50s | $38.17 | 0 | | simplify_gpt | 8m 27s | $2.24 | 0 | | verify | 6m 10s | – | 0 | | fixup | 42m 1s | $31.00 | 0 | | fmt | 3s | – | 0 | | **Total** | **217m 39s** | **$129.86** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (12 nodes and 15 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --cargo-quiet --workspace --status-level fail 2>&1 && cargo dev docs refresh 2>&1 && cargo dev docs check 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all clippy lint warnings, test failures, and generated docs errors.", max_visits=3] fmt [label="Format", shape=parallelogram, script="cargo +nightly-2026-04-14 fmt --all 2>&1", max_retries=0] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> fmt [condition="outcome=succeeded"] verify -> fixup fixup -> verify fmt -> exit } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: Bryan Helmkamp <bryan@brynary.com> Co-authored-by: Bryan Helmkamp <bhelmkamp@users.noreply.github.com>	2026-05-23 13:03:21 -04:00
fabro-sh-0530[bot]	a42634cc54	Add event-sourced todo tools for OpenAI and Anthropic profiles (#353) ... ## Summary Adds a shared todo/task engine behind two model-native tool surfaces, with all mutations persisted as individual run events and replayed into `RunProjection`. ### Plan Summary - **New domain types** in `fabro-types`: `TodoStatus`, `TodoListKind`, `TodoProjection`, `TodoListProjection`, and `todos_by_list` on `RunProjection`. - **New run events**: `todo.created`, `todo.updated`, `todo.deleted` — mapped through Fabro's typed event pipeline and replayed by `RunProjectionReducer`. - **`TodoRuntime`** (`fabro-agent`): thread-safe in-memory projection shared across tool closures within a profile instance; each mutation emits the corresponding agent event. - **`update_plan`** registered only in `OpenAiProfile`: reconciles incoming steps by exact `step` text (sha256-derived ID), emitting create/update/delete events to match the submitted plan. - **`TaskCreate` / `TaskUpdate` / `TaskList`** registered only in `AnthropicProfile`: numeric task IDs per list, metadata merge with `null`-key deletion, `status: "deleted"` routes to `todo.deleted`. - **Session identity threading**: `ToolContext` gains `session_id`, `root_session_id`, `tool_call_id`, and `agent_event_emitter`; `execute_tool_calls` threads these through to `execute_one_tool`; `Session` tracks `root_session_id` and `spawn_agent` inherits it for subagents. - **Scoping**: OpenAI todos scope to `openai_plan:<session_id>` (per-session); Anthropic todos scope to `anthropic_tasks:<root_session_id>` (shared across subagents). - **Web invalidation**: `todo.*` events invalidate `getRunState` and the run events list; tested in `run-events.test.tsx`. ```mermaid graph TB subgraph OpenAI UP[update_plan] -->|diff by step text| TR[TodoRuntime] end subgraph Anthropic TC[TaskCreate] --> TR TU[TaskUpdate] --> TR TL[TaskList] -->|read-only snapshot| TR end TR -->|emit todo.created/updated/deleted| SE[SessionBoundEmitter] SE --> EV[AgentEvent stream] EV --> RP[RunProjection\ntodos_by_list] ``` ### Key design decisions - **Step identity by text, not position** (`update_plan`): a sha256-derived ID from `list_id + step` means reordering without renaming emits an update rather than a delete+create. Duplicate step strings are rejected with a model-visible error because text is the identity. - **No plan-replace event**: the engine emits only individual mutation events; bulk replacement is expressed as a set of create/update/delete events produced by diffing the incoming plan against the projection snapshot. - **`TodoRuntime` per profile instance**: tools inside a single profile share one runtime. OpenAI subagents each have their own `session_id` so their plans are isolated; Anthropic subagents inherit `root_session_id` so tasks are shared — matching upstream Codex/Claude behavior. - **`AgentEventEmitter` trait on `ToolContext`**: a narrow interface that lets tools publish typed events without taking a dependency on the full `Emitter`. `SessionBoundEmitter` wraps `Emitter` and stamps `session_id` + `tool_call_id` on each event. ### Fabro Details <details> <summary>Ran 9 stages in 93m 23s for $56.46</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 6s | – | 0 | | preflight_lint | 2m 20s | – | 0 | | implement | 41m 30s | $38.21 | 0 | | simplify_opus | 29m 2s | $11.78 | 0 | | simplify_gpt | 14m 24s | $6.46 | 0 | | verify | 3m 2s | – | 0 | | fmt | 3s | – | 0 | | **Total** | **93m 23s** | **$56.46** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (12 nodes and 15 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD."] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --cargo-quiet --workspace --status-level fail 2>&1 && cargo dev docs refresh 2>&1 && cargo dev docs check 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all clippy lint warnings, test failures, and generated docs errors.", max_visits=3] fmt [label="Format", shape=parallelogram, script="cargo +nightly-2026-04-14 fmt --all 2>&1", max_retries=0] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> fmt [condition="outcome=succeeded"] verify -> fixup fixup -> verify fmt -> exit } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: Bryan Helmkamp <bryan@brynary.com>	2026-05-22 13:44:42 -04:00
fabro-sh-0530[bot]	199cf0822e	feat: gate Fabro run tools by worker JWT scope (#351) ... Fabro run tools are now gated behind an explicit per-run opt-in so workflow agents only receive those capabilities when the run requests them. ## What changed - **`fabro_tools` setting** (`run.agent.fabro_tools`, default `false`) is resolved through the existing TOML config layer stack. - **Worker JWT scope** adds `agent:run_tools` only when the resolved setting is `true`; default worker tokens carry only `run:worker`. - **Worker tool registration** derives from the worker JWT scope claim. The CLI worker locally decodes the token payload and registers `FabroRunToolServices` only when the scope includes both `run:worker` and `agent:run_tools`. - **Server-side authorization remains authoritative**. The worker-side decode is only a local tool-registration gate; the server still validates token signature and scopes before accepting run-tool API calls. > **Behavior change:** existing runs that relied on Fabro run tools being always available must add `[run.agent] fabro_tools = true` to their workflow config. ## Verification ```sh cargo +nightly-2026-04-14 fmt --all cargo test -p fabro-cli fabro_run_tools_enabled_token_requires_run_tools_scope cargo test -p fabro-server worker_command_ cargo test -p fabro-static cargo +nightly-2026-04-14 clippy -p fabro-cli -p fabro-server -p fabro-static --all-targets -- -D warnings git diff --check ``` --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: Bryan Helmkamp <bryan@brynary.com>	2026-05-22 12:12:17 -04:00
fabro-sh-0530[bot]	f5f921aa3c	feat: add [run.agent] fabro_tools opt-in for worker run tools (#348) ... ## Summary Workflow agents previously always received the `agent:run_tools` JWT scope and had Fabro run tools registered unconditionally. This PR makes Fabro run tool access an explicit per-run opt-in via `[run.agent] fabro_tools = true`, defaulting to `false`. ## What changed **Config layer** (`fabro-types`, `fabro-config`): `RunAgentSettings` gains a `fabro_tools: bool` field (serialized with `#[serde(default)]` for backward compatibility). The corresponding `RunAgentLayer` gets an optional `fabro_tools: Option<bool>` that resolves to `false` when absent. Layer merging follows the existing `Combine` macro semantics, so a workflow-level `false` overrides a user-level `true`. **Server** (`fabro-server`): `worker_command` gains an `agent_fabro_tools_enabled: bool` parameter. The server reads `run_state.spec.settings.run.agent.fabro_tools` from the stored run before spawning `__run-worker`, then issues the worker JWT with either `["run:worker"]` or `["run:worker", "agent:run_tools"]` accordingly. `WorkerScopeSet::run_worker()` loses its `#[cfg(test)]` gate so it's available in production paths. **CLI worker** (`fabro-cli`): `FabroRunToolServices` construction is now gated on `run_spec.settings.run.agent.fabro_tools` rather than being unconditional. The resolved run spec already carries the setting, so no env-var parsing is needed in the runner. **Tests**: The single monolithic `worker_command_always_sets_worker_token_env` test is replaced by two focused tests — one confirming the default scope is `["run:worker"]` only, and one confirming the opt-in scope includes `agent:run_tools`. Shared assertion logic is extracted into `assert_worker_command_passes_token_only_by_env` and `worker_token_claims` helpers. Config resolver tests cover default, explicit true/false, and layer-override behavior. **Docs**: `[run.agent]` description and reference tables are updated; a new `run-configuration.mdx` section explains the opt-in semantics before the existing `[run.agent.mcps]` section. ### Plan Summary - 1. Add `fabro_tools` to resolved and layered run config, with resolver tests. - 2. Gate worker JWT scope and pass setting from stored run state into `worker_command`. - 3. Gate CLI `FabroRunToolServices` construction on the resolved setting. - 4. Update docs generator sample and public reference/execution docs. - 5. Full verification pass (nextest, fmt, clippy). ### Fabro Details <details> <summary>Ran 9 stages in 54m 4s for $15.21</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 4s | – | 0 | | preflight_lint | 2m 18s | – | 0 | | implement | 28m 5s | $10.58 | 0 | | simplify_opus | 12m 4s | $2.86 | 0 | | simplify_gpt | 5m 19s | $1.77 | 0 | | verify | 3m 37s | – | 0 | | fmt | 3s | – | 0 | | **Total** | **54m 4s** | **$15.21** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (12 nodes and 15 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD."] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --cargo-quiet --workspace --status-level fail 2>&1 && cargo dev docs refresh 2>&1 && cargo dev docs check 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all clippy lint warnings, test failures, and generated docs errors.", max_visits=3] fmt [label="Format", shape=parallelogram, script="cargo +nightly-2026-04-14 fmt --all 2>&1", max_retries=0] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> fmt [condition="outcome=succeeded"] verify -> fixup fixup -> verify fmt -> exit } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: fabro-agent <agent@fabro.local>	2026-05-22 09:41:27 -04:00