# Changelog All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ## [Unreleased] Pending changes are collected as fragment files in [`changelog.d/`](changelog.d/) and compiled into this file at release time. ## [0.1.45] - 2026-11-10 ### Fixed - Fix Anthropic agents failing when no model is set: the default is now `claude-sonnet-4-6` (agent builder and `ClaudeProvider`) instead of the retired `claude-3-5-sonnet-latest`. (#621) - The `claude-agent-sdk` provider now defaults to `claude-sonnet-4-6` instead of `claude-sonnet-4-5`, which Anthropic retires on 2026-11-30, when neither the agent nor the workflow sets a model. (#628) - Default OpenAI model is now `gpt-5.6-terra` instead of `gpt-5-mini`, which OpenAI retires on 2026-12-11 (agents without a model would fail after that date). If you rely on the implicit model default, review your budget or select a model explicitly. See the [GPT-5.6 Terra pricing](https://developers.openai.com/api/docs/models/gpt-5.6-terra). (#632) - Fix cost reports pricing Claude Opus 5.5 and Sonnet 5.5 at the older Claude 5 rates, and add pricing for Claude Fable 5.1; Claude Sonnet 5 now uses its current $2/$10 per MTok standard price. (#633) ### Changed - The Claude and Claude Agent SDK example workflows now use `claude-sonnet-4-6` instead of `claude-sonnet-4-5`, which Anthropic retires on 2026-11-30. (#627) ## [0.1.44] - 2026-11-01 ### Added - **Agent execution realms and profiles**: run LLM agents in isolated Docker containers or Azure Container Apps dynamic sessions via `execution.profile`. Docker profiles accept `runner_image` to execute the agent loop, stdio MCP tools, and staged workspace dependencies colocated in a long-lived runner container. Remote runners support `/interrupt` for targeted mid-turn pauses, multi-provider execution (Copilot, OpenAI, Claude), and per-call agent-scope secret delivery (`env_overlay`) to stdio MCP processes without leaking into the runner process environment. Host-resolved credentials and endpoints stay authoritative inside the runner. Docker interrupt delivery remains monitored through transport shutdown, and a racing completion preserves its result. Retained Docker workspaces record agent dispatch so resume refuses a missing staging marker rather than overwriting agent-written files. **ACA execution profiles**: configure the pool and session scope under an environment profile's `aca` block, independently of the agent's model provider. The legacy `provider: aca` form remains available with a deprecation notice. (#598) ### Fixed - **Fleet TUI gate text entry**: choosing **✎ Write your own** on a `questions` step, or any gate option that declares `prompt_for`, now opens an editor in the Fleet Manager and responds only once the text is confirmed (`enter` for single-line, `ctrl+s` for multi-line). Previously the selection was sent immediately with no text, advancing the question unanswered. Pressing `esc` in the editor sends nothing and leaves the question pending; `g` reopens it. (#620) ### Removed - The obsolete `conductor.providers.aca_protocol` module has been removed; import runner wire models from `conductor.runner.protocol` instead. (#598) ## [0.1.43] - 2026-10-29 ### Added - **Retained workspace lifecycle, honest resume digest gate, and restart policy**: Workflows running on the Docker execution backend can now retain container workspace volumes across failures and resumptions using `workflow.workspace` (`persistence: on-failure` or `durable`). On resume, Conductor enforces an honest digest gate that verifies bundle content (when recorded) and manifest semantic digests against the checkpoint's resume contract before attaching or altering retained Docker volumes. Resumption also respects step-level `restart:` policies (`rerun` or `fail`), controlling whether interrupted in-flight steps re-execute or fail closed. (#597) ### Fixed - The `copilot` provider now enforces per-agent tool allowlists on the SDK session; previously every agent silently received the CLI's full tool catalog. Explicit agent tool lists, including `tools: []`, are enforced. When agent tools are omitted, a non-empty workflow tool list is inherited; an empty workflow list retains the SDK's default tools. MCP tools named `server__tool` are translated to the Copilot runtime's `server-tool` name, so allowing one no longer hides it. (#585) - **Claude Code plugin marketplace**: `/plugin install conductor@conductor` no longer fails with `Source path does not exist`. The marketplace entry now points at `./plugins/conductor`, relative to the repository root as Claude Code resolves it, and the unused `metadata.pluginRoot` is removed. (#587) - Fleet now shows tokens and estimated costs for newly recorded runs whose agents execute in sub-workflows, including usage on workflow-step detail rows. (#588) - **MCP registry defaults**: server startup now checks for a newer default-branch commit even with a warm cache, while retaining the recorded SHA as a fallback when ref resolution fails. (#595) ### Changed - **Leaner agent instructions**: the root `AGENTS.md` is now a short set of universal rules and a task router (about 7 KB, down from 238 KB), with contributor detail moved to on-demand guides under `docs/development/`. A `conductor run --workspace-instructions` launched in this repository now injects that short router rather than the full architecture notes; pin a guide explicitly with `--instructions` or a workflow's `instructions: [!file ...]` when a run needs it. The Claude provider guide moved to `docs/providers/claude-provider.md` (the old path is a short pointer, so it is no longer auto-discovered as a 31 KB `CLAUDE.md` on case-insensitive filesystems), and the workspace-instructions docs now describe how scoped `.github/instructions/` files are actually selected and that YAML `instructions:` entries are literal text unless loaded with `!file`. (#574) ## [0.1.42] - 2026-10-06 ### Added - **Template filter `fromjson`**: added a `fromjson` Jinja filter that parses JSON text into native values, the inverse of the existing `json` filter. MCP step results (for example `output.content[0].text`) can now be parsed inside templates to build arguments for downstream steps. (#579) - **Docker execution backend for containerized script steps**: executes `type: script` workflow steps inside short-lived containers against a run-scoped shared named volume (`conductor-ws-`). Execution environment documents declare `docker` profiles with configurable container image, target platform, network mode, container user, init process, read-only root filesystem, Linux capability drops, privilege escalation blocks, memory-backed `/tmp` tmpfs mounts, and CPU, memory, and PID resource constraints. Conductor automatically collects the workflow's content-addressed run bundle closure and stages it into the shared volume before execution, isolating script steps while preserving shared workspace state across steps within the run. (#584) - Opt-in live-validation harness and operator runbook for Claude subscription billing mode. (#586) ### Changed - **Dependabot-authored pull requests no longer require changelog fragments**: the check recognizes Dependabot from the pull request author while continuing to reject direct `CHANGELOG.md` edits and validate any fragment changes. (#578) ## [0.1.41] - 2026-09-29 ### Added - **Run bundles and offline closure reporting**: added `conductor bundle build` to package self-contained, content-addressed workflow closures into `$CONDUCTOR_HOME/cache/bundles/`, the `workflow.bundle` YAML block for declaring static assets and additional authorized roots, and the offline Bundle Closure section in `conductor validate --environment`. (#568) - **Secret bindings contract**: workflows can now declare logical secret requirements on executable script steps (`execution.secrets`) and MCP servers (`runtime.mcp_servers..secrets`), which execution environment documents bind to credential sources (`source.env`) and gate via optional `allow` consumer policies. Resolved secrets are delivered via targeted environment variables or HTTP headers and automatically sanitized across event streams, checkpoints, logs, and diagnostics. Workflows and environments without secret declarations continue to run with zero changes. (#571) - `claude-agent-sdk` executions now record where their model usage is billed from (a Claude Code subscription, a metered API key, or unknown), and cost figures are labelled to match. Subscription usage is shown as an **API-equivalent estimate** rather than as a charge; mixed workflows say so and break the executions down; providers that do not report a billing source are displayed exactly as before. The label appears in the console usage summary, per-agent progress lines, budget messages, `conductor status`, the web dashboard, and the Fleet Runs, Run Detail and History screens, and is carried as `billing_mode` on agent completion events and as `billing` in MCP run-status payloads. A billing source is only claimed when it can be proven: an inherited cloud-backend selector, gateway token, custom endpoint, or settings tier gives `unknown`. `limits.budget_usd` still applies to the estimated cost. (#573) ### Fixed - Script completion now shows non-zero exit codes, and route failures identify the source step, destination, expression and bounded script diagnostics instead of misidentifying missing output fields as undefined variables. (#559) - **GitHub registry authentication**: select the GitHub.com credential even when `GH_HOST` points to a GitHub Enterprise host, without changing the environment seen by workflow scripts. (#560) - `conductor registry list` displays `OK` instead of a checkmark for the default registry when the output encoding cannot represent the checkmark, avoiding a crash on legacy Windows consoles. (#561) - **Private-index installer recovery guidance** now safely bridges an existing pip mirror into uv and recommends current system-certificate settings. (#536) - A `$` written directly before a Jinja expression, as in `${{ workflow.input.budget }}`, is no longer read as an environment variable reference, so the workflow loads instead of failing with "Required environment variable '{ workflow.input.budget ' is not set". (#572) - Interrupting a `claude-agent-sdk` agent, or hitting its `max_session_seconds` limit, no longer waits for the SDK to deliver another message before taking effect — a run blocked waiting on the model now stops when asked. The session limit is a single deadline measured from the start of the execution, so a steady stream of messages can no longer extend it indefinitely. Conductor now also owns the shutdown of the Claude CLI session rather than leaving it to the SDK's own stream teardown, which an interrupt or an expired deadline could previously cut short and leave a CLI process running. Shutdown is never cancelled, is retried once if it does not complete, and finishes before that execution's temporary MCP configuration is deleted. If it cannot be confirmed, the failure is logged; on a run that would otherwise have succeeded the result is discarded and a non-retryable error is raised instead of reporting success while the CLI may still be running. Two consequences are worth knowing: a signal raised while the CLI is still starting up takes effect only once startup finishes, and returning after an interrupt or a timeout may take additional time while the SDK releases its resources. Startup is normally quick, but nothing places an overall limit on either delay. (#570) ## [0.1.40] - 2026-09-23 ### Added - **Execution profiles and execution environment documents:** decouple what an executable step needs from where it runs. Workflows declare logical profile names via `workflow.defaults.execution.profile` or per-step `execution.profile` on executable steps (agent, script, mcp, workflow). Environment documents (`.conductor/environments/.yaml` discovered by walking from the workflow directory to the git root, or `$CONDUCTOR_HOME/environments/.yaml`) map logical profile names to runner backends via whole-document shadowing without merging. CLI commands `conductor run`, `conductor resume`, and `conductor validate` accept `--environment ` to select an environment. Bare `conductor validate` uses a three-level check: zero I/O when profile references are absent, discovery and cross-checks when present, and explicit validation with a full `Execution Resolution` report table when passed `--environment`. Every run compiles a deterministic, run-invariant `ResolvedRunManifest` audit record recorded in `workflow_started` metadata. See `docs/workflow-syntax.md` (Execution Profiles) and `docs/configuration.md` (Execution Environments). (#527) - **`dialog.conversation_prompt`**: instructions for the agent holding a dialog conversation, appended to the built-in dialog system prompt. Previously `trigger_prompt` was the only field on a `dialog:` block, and it reaches only the evaluator that decides whether to open the dialog, so a workflow author had no way to instruct the conversing agent. ### Fixed - **Verbose logging and error reporting no longer crash a run when stderr is a non-blocking pipe**: a full agent prompt (or any other large console panel) could exceed the OS pipe buffer and raise `BlockingIOError` under `--web-bg`, cron, or any other piped/non-interactive invocation, taking down an otherwise successful workflow. The write now blocks for the reader to drain the pipe instead of failing outright. (#543) - **Dialog mode no longer ends an interview on "ready for the next question"**: a trailing `[READY_TO_CONTINUE]` is withheld when the agent's message still asks or announces a question, the agent is told not to combine the two, and the continue prompt names the agent and says which replies end the dialog (`yes`, or a dismiss keyword; anything else is sent to the agent, and an empty reply re-asks). The opening banner lists every dismiss keyword, and `dialog_completed` carries `agent_question_outstanding` when a dialog closed under an unanswered question from the agent. On the web path the leave-dialog control and a dismiss keyword at the continue proposal both end the dialog as a dismissal, as on the terminal. ### Changed - **Remote runner wire protocol lifted to `conductor.runner.protocol`**: the serialized wire contract between the Conductor host and remote agent runtimes is now defined in the backend-neutral `conductor.runner.protocol` package. The runner `/health` endpoint additively advertises `protocol_version` for host-side version advertisement and warn-only compatibility checks. `conductor.providers.aca_protocol` is deprecated as a re-export shim that emits a `DeprecationWarning` on import and will be removed in a future major release. (#527) - **Copilot agent system prompts now use the SDK's native system channel** instead of being prefixed to each dynamic user prompt, improving instruction role integrity and allowing static prompt prefixes to remain cacheable. (#545) - **Breaking (experimental `claude-agent-sdk` provider):** an agent that omits `tools:` no longer receives the full Claude Code tool preset. The new `runtime.provider.native_tools` setting defaults to `none` — no built-in filesystem, shell, web or editing tools — including for the bare `provider: claude-agent-sdk` shorthand. Workflows that relied on omitting `tools:` to read files, run commands or edit code must now opt in explicitly with `native_tools: claude_code`; without it they still validate, but their agents run with no built-in tools. `claude_code` grants the full preset with automatic approval, and the run warns once that `working_dir` is not a sandbox. Under `none`, declared MCP servers stay usable through one server-scoped permission rule each (`mcp____*`). Server names are restricted to letters, digits, `-` and single `_` characters so the rule matches the tool names the CLI actually generates; a name that cannot form a matching rule, and plugin subagents that would have no dispatch tool, are refused at `conductor validate` and at run time. An explicit `tools: []` on an agent that would still get MCP servers, from the workflow or a plugin, is now refused by `conductor run` as well as by `conductor validate`, instead of running with those servers attached. - The default development and CI test commands now run the isolated pytest suite in parallel, substantially reducing feedback time on multi-core machines. Set `PYTEST_WORKERS=0` when a serial run is needed for debugging. ## [0.1.39] - 2026-09-21 ### Added - **`claude-agent-sdk` provider: explicit authentication mode selection.** The new `runtime.provider.auth_mode` field (`"auto"` default, `"subscription"`, `"api_key"`) selects which credential the `claude` child process uses. `auto` leaves the inherited environment unchanged, so existing workflows are unaffected. `subscription` blanks `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN` and `CLAUDE_CODE_OAUTH_TOKEN` in the child environment; `api_key` requires a non-blank `ANTHROPIC_API_KEY` and blanks the other two. Both explicit modes refuse an inherited non-blank `CLAUDE_CODE_USE_BEDROCK` / `_VERTEX` / `_FOUNDRY` cloud-backend selector, naming the variable but never its value; `auto` keeps it. Both explicit modes also refuse a non-empty `setting_sources`, at `conductor validate` and at run time, because a Claude Code settings file's `env` block is applied after Conductor configures the child environment. Each agent execution captures its environment, working directory, settings tiers, and CLI path once; a readiness check (`claude auth status --json`, skipped for `api_key`) and the SDK session both use that capture — including the same settings tiers, passed to the check as `--setting-sources` — and Conductor's own environment is never modified. Every mode, `auto` with an API key included, requires the `claude` CLI to be installed, checked without running it. The readiness check is not billing attribution. `conductor doctor --check` shows Conductor's inferred mode separately from the CLI-reported `authMethod` / `apiProvider` / `apiKeySource` / `subscriptionType`, and states that it checked the default provider configuration rather than any workflow's `auth_mode`. See `docs/workflow-syntax.md` (Authentication Mode) and `docs/configuration.md`. (#522) ### Fixed - Fixed skill and plugin path diagnostics on Python 3.14, whose rewritten `pathlib` makes `exists()`, `is_dir()` and `is_file()` swallow `PermissionError` and return `False`: an unreadable skill path, plugin path, local plugin source, or skills-root subdirectory is once again reported as "could not be read" instead of being misreported as missing or silently skipped. Also excluded `performance`-marked tests from the default `make test` and `make test-cov` targets, matching CI. (#540) - **Astra cost reporting**: added static pricing for `gpt-6-astra`, including input, output, cache-read, and cache-write token rates, so costs remain available when live Copilot billing metadata cannot be resolved. (#549) ### Changed - **`!file` no longer YAML-sniffs its content; `!yamlfile` replaces the old content-detection heuristic for structured includes**. Whether `field: !file some/path` returned a string or a parsed dict/list used to depend on the referenced file's exact content: a Markdown prompt whose prose happened to parse as a YAML mapping (a line ending in `:` followed by a `- ` bulleted list, for example) was silently returned as a dict, and an unrelated prose edit could flip a working prompt across that boundary with no config change. `!file` now always returns the file's content verbatim as a string. A new `!yamlfile` tag explicitly parses the referenced file as YAML and raises a `ConfigurationError` naming the file if it isn't valid YAML, instead of silently falling back to a string. **Breaking change** for any workflow using `!file` to load structured YAML (an output schema, a tool list, a nested config file): switch that reference to `!yamlfile`. For example, `output: !file schemas/analysis-output.yaml` becomes `output: !yamlfile schemas/analysis-output.yaml`. A `!file` include that only ever held plain text (`prompt`, `system_prompt`, a description field) needs no change; only `!yamlfile` recurses into nested `!file`/`!yamlfile` tags, so a structured include with its own nested includes needs the outer tag switched too. See [`docs/workflow-syntax.md`](docs/workflow-syntax.md#external-file-references). (#528) - **AnyIO dependency**: updated the locked indirect dependency from 4.12.1 to 4.14.2. (#539) - **Script subprocesses are now always killed and reaped when a workflow run is cancelled.** Script-step execution also now runs through a pluggable backend seam owned by the workflow engine — a stdlib-only `conductor.execution` contract (`RunnerBackend` protocol, data-shaped `CommandResult`/`StartError`, run-scoped `WorkspaceLease`) with a local subprocess reference implementation (`LocalRunnerBackend`). The root engine prepares the run's workspace lease in `run()`/`resume()` and finalizes it in the matching `finally` with the run's outcome (succeeded/failed/cancelled); sub-workflows inherit the root run's backend and lease, so one run owns exactly one lease. **No behavior change**: rendered commands, environment handling, timeouts, error messages, and exit-code routing are unchanged; the new backend seam otherwise preserves existing behavior. (#541) ## [0.1.38] - 2026-09-21 ### Added - **Opt-in OpenTelemetry tracing for workflow execution** — setting `OTEL_EXPORTER_OTLP_ENDPOINT` now exports one trace tree spanning workflows, agents, parallel and for-each groups, deterministic steps, gates, model calls, and tool executions. Conductor integrates native Pydantic AI spans for the `claude` and `openai` providers and native Copilot CLI spans over OTLP HTTP, while preserving any tracer provider installed by a host application. See [`docs/telemetry.md`](docs/telemetry.md) and [`examples/telemetry.yaml`](examples/telemetry.yaml). (#482) - **Direct MCP workflow steps (`type: mcp`)**: calls a tool on a configured `runtime.mcp_servers` stdio server directly without an LLM. Arguments are rendered recursively with Jinja2 and auto-coerced to JSON-native types; the result envelope (`content`, `structured`, `is_error`) merges structured keys directly onto the output dict so routes and downstream steps can branch on `output.is_error` or individual fields. Calls serialize per server process to maintain stdio stream integrity while distinct servers execute concurrently in parallel groups. Output text payload is bounded by `runtime.tool_output` with spill-to-file support while structured data is preserved intact. Step and result values are excluded from all lifecycle events (`mcp_started`, `mcp_completed`, `mcp_failed`), with failure messages redacted to a safe category and full exception traces written only to a private per-run `*.mcp-diagnostics.log` file (named by the redacted message). See [`docs/workflow-syntax.md`](docs/workflow-syntax.md#mcp-steps) and [`examples/mcp-step.yaml`](examples/mcp-step.yaml). (#392) - **GitHub registries now fetch a workflow's nested assets recursively** — previously the cache layer only fetched a workflow's YAML plus its immediate siblings, so a `prompt: !file prompts/plan.md` or a script step reading a nested `scripts/`/`data/` file one or more directories below the workflow YAML silently failed to resolve once cached. `conductor.registry .github.list_files_recursive` walks the workflow's containing directory via the Git Trees API (an explicit stack of non-recursive tree requests, never a single `recursive=1` call and never the Contents API's 1,000-entry cap), downloading every regular file at its original repository-relative path; symlinks and submodules are excluded and logged, never followed. Acquisition is strictly all-or-nothing: a failure listing any subdirectory, downloading any regular file — including one the workflow itself never references — or promoting a staged file into the shared SHA cache aborts the whole fetch with a contextual error naming the failing path, rather than silently completing a partial cache. A root-level workflow's containing directory is the whole repository, so give a workflow its own directory to keep fetches scoped. The on-disk cache layout version is bumped, and per-workflow readiness markers now carry that version rather than being an empty presence-only marker, so an existing cache automatically and transparently refetches under the new recursive contract the next time it's needed online; an offline-only caller against a stale cache still gets the existing actionable cache-miss error. Path registries are unaffected — they already read the source tree directly. (#530) - **OpenTelemetry spans for direct MCP workflow steps**: each `type: mcp` execution is exported as an `execute_tool` span under its workflow, parallel group, or for-each item. Spans include bounded server, tool, result-size, and truncation metadata without recording arguments, result contents, or spill paths, and preserve routed tool errors, execution failures, and interrupted attempts as distinct outcomes. (#482) ### Fixed - **`conductor run --dry-run` no longer crashes on legacy stdout encodings because of its own decorative glyphs** — the execution-plan renderer hardcoded the `→` route arrow and `⚡` parallel-group marker, so a Windows console using `cp1252` (or any other stream that cannot encode them) died mid-render instead of printing the plan. `display_execution_plan` now resolves both glyphs once against its actual output console, via a shared `conductor.console.select_console_glyph` helper, and falls back to `->`/`*` when the stream cannot represent the Unicode originals — matching the fallback `conductor doctor` already used for its own status glyphs. This covers only those two Conductor-authored decorations; workflow-provided text (agent names, prompts, etc.) is rendered unchanged and must still be encodable to the target stream. (#505) - **Summarizing context compaction no longer degrades on long agent runs** — the nested summarization call now inherits the run's `usage_limits` instead of falling back to Pydantic AI's default `request_limit=50`. With pydantic-ai-harness 0.24.0 the summarizer shared the parent run's usage but not its limits, so an agent configured with `max_agent_iterations` above 50 was refused a summary once it had made 50 requests — the tier silently degraded to the sliding-window fallback exactly when a long run needed real summarization, and the under-compacted history could then exceed the model's context window and fail the run with an HTTP 400. The summary call still consumes one shared request slot, so a genuinely exhausted budget still refuses it. (#531) - **`conductor mcp serve` now launches workflows from the Copilot host's working directory, not the server's own installation directory** — a workflow invoked through a generated MCP tool used to run with whatever cwd the server process itself inherited (typically wherever the Copilot plugin was installed), regardless of the repository the operator was actually working in. The server now detects the Copilot host process's own cwd at startup (walking its own process ancestry, through any intervening launch wrappers) and launches every workflow for that process's lifetime in that directory instead. This is a fixed startup snapshot, not a live value: it is captured once and never re-resolved, even across a long-running connection. A new `--launch-dir ` flag overrides detection entirely, for an exact historical directory, a session-specific one, or when no Copilot host can be identified. (#544) - **MCP launch-directory output remains copyable on narrow terminals**: startup summaries and validation errors no longer insert line breaks inside long paths. (#548) - **Nested human gates now work in background workflows** — child workflow engines inherit the parent process's background mode, so a `human_gate` inside a `type: workflow` step waits on the web dashboard instead of trying to prompt unavailable stdin and failing with `EOFError`. (#525) - **Pydantic AI structured-output agents explicitly require `final_result`** — the generated output tool now tells models that they must call it before finishing and that plain-text responses are not accepted. This improves adherence for local models behind OpenAI- or Anthropic-compatible endpoints without replacing tool-based output, weakening schema validation, or changing authored system prompts. (#524) - **Resumed Copilot sessions preserve custom provider routing** — workflows using `runtime.provider` settings such as `base_url`, `api_key`, `type`, or `wire_api` now apply the same routing to `resume_session` as to a newly created session, instead of silently falling back to the default Copilot endpoint after resume. (#534) - **Terminal left in cbreak mode (no echo/ICANON) after a run exited** — a `KeyboardListener` started while the terminal was already in cbreak mode (after an Esc pause/resume cycle, or a second listener in the same process) captured that cbreak state as its "original" settings and restored it on `stop()`, leaving the user's interactive shell without echo or canonical mode. The tty baseline is now captured once per process, before the first `tty.setcbreak()`, and reused by every later listener; `start()` is idempotent while active so a duplicate call can't overwrite the baseline; restore uses `TCSANOW` so a blocked output drain can't delay it; and the saved baseline is cleared only after a successful `tcsetattr` so a transient failure can be retried by `atexit`/`SIGTERM`/`stop()`. The SIGTERM cleanup handler also no longer swallows the signal: after restoring the terminal it delegates to the previously-installed disposition (reset-and-re-raise for `SIG_DFL`, ignore for `SIG_IGN`, invoke a callable previous handler), and re-registration captures the previous disposition in the handler closure so the listener can no longer recurse into itself. The run and resume commands now also reapply and retire the baseline at their outermost cleanup boundary, after provider shutdown and every other teardown step. This closes a later race where normal completion or Ctrl+C could restore the terminal correctly and then a provider's cleanup could put it back into cbreak; SIGTERM during that same late-cleanup window restores the process baseline before terminating. ([#290](https://github.com/microsoft/conductor/issues/290)) ### Changed - **Step definitions split into concrete models with a discriminated union** — the single monolithic `AgentDef` that carried every step type's fields is now a set of focused Pydantic models: `AgentDef` (provider-backed LLM agents only), `HumanGateStepDef`, `QuestionsStepDef`, `ScriptStepDef`, `MCPStepDef`, `WaitStepDef`, `SetStepDef`, `TerminateStepDef`, and `WorkflowStepDef`, united by the static `StepDef` union discriminated on `type`. Every model owns exactly the fields meaningful for its kind with `extra="forbid"`, so a misplaced field is rejected next to its step instead of being silently ignored, and the published JSON Schema now exposes a `oneOf` + `discriminator` mapping with per-variant `additionalProperties: false` for editors and tooling. Compatibility: workflow YAML is unchanged — an omitted `type` or an explicit `type: null` still loads as an LLM agent (now canonicalized to `type: "agent"` at parse time) — and `AgentDef(...)` keeps working for LLM agents, including `AgentDef(type=None, ...)`. What changed: constructing a non-LLM step programmatically via `AgentDef(type="script", ...)` no longer works — use the named step class (e.g. `ScriptStepDef(...)`) — and a field that belongs to a different step type now fails with Pydantic's standard `extra_forbidden` error rather than the previous custom `" agents cannot have ''"` messages. Human gates additionally lost the inert `model` field and can no longer appear as a `for_each` inline agent (concurrent iterations would compete for one interactive channel; route to a gate from the group's `routes:` instead). All classes are exported from `conductor.config` and `conductor.config.schema`. (#517) ## [0.1.37](https://github.com/microsoft/conductor/compare/v0.1.36...v0.1.37) - 2026-09-09 ### Added - **Always-on client-side context compaction for the `claude` and `openai` providers** (#503) — an agent whose conversation outgrows the model's context window no longer fails the run. Conductor condenses the history once it crosses a calculated trigger threshold and continues. The trigger is computed from an additive reserve formula — context window minus output limit minus an effective tool-output-derived buffer (clamped to at most 25% of the window) — and compaction is disabled, with a `disabled_reason` on the `agent_compaction_config` event, when the remaining trigger would fall below 4096 tokens. Condensing runs a three-stage strategy: clearing old tool results first, summarizing older messages with a nested model call, and sliding the window as a deterministic fallback. It is client-side only, so behaviour is identical behind an API proxy, always on with no new YAML surface, and fail-open — a compaction failure never aborts a run, and an unrecovered one disables compaction for the rest of that agent execution. Every compaction is surfaced in the console, the JSONL event log, and the web dashboard. - **Provider-advertised model token-limit metadata** (#503) for compaction sizing. The `claude` and `openai` providers read per-model input/output token limits from their SDK model listings (with full pagination for the Anthropic SDK, and a vendor-field parser for OpenAI-compatible endpoints), the `copilot` provider implements the `get_max_output_tokens` hook, and resolution falls back through the `genai-prices` registry to a conservative default. - **Opt-in `runtime.provider.setting_sources` on `claude-agent-sdk`** (#501) — selects which Claude Code settings tiers (`user` / `project` / `local`) a session may load. It is empty by default, so behaviour is unchanged unless a workflow asks: the provider still sends an explicit `[]`, which is load-bearing because the SDK re-defaults an unset value to `["user", "project"]` whenever `skills` is set. The case it exists for is an agent whose `working_dir` is a *target* repository shipping its own `.claude/skills` — the SDK has `--plugin-dir` but no `--skill-dir`, so that repo otherwise has to package its skills as a Claude Code plugin; `[project]` reads them, and the repo's `CLAUDE.md` / `.claude/rules` with them. An enabled tier brings that tier's **hooks**, so it is only for repositories trusted as much as the workflow itself; the field is rejected on every other provider name rather than accepted and silently ignored, counts as structured config (so `--provider` overrides warn before discarding it and `-v` shows it), and a per-agent `skills: []` opts that agent out of the tiers entirely. See [`examples/claude-agent-sdk-setting-sources.yaml`](examples/claude-agent-sdk-setting-sources.yaml). - **OpenTelemetry tracing**, new opt-in OpenTelemetry tracing feature activated by `OTEL_EXPORTER_OTLP_ENDPOINT`. It instruments workflow orchestration to emit spans for workflows, agents, parallel/for-each groups, steps, and tool executions. For `claude` and `openai` providers, it also registers and enables native Pydantic AI instrumentation; for `copilot`, it captures native spans from the Copilot CLI child process over OTLP HTTP. In each case Conductor unifies orchestrator spans and LLM/tool calls into a single trace tree. Tracing is enabled by configuring standard `OTEL_*` environment variables for an OTLP collector. See `docs/telemetry.md` and `examples/telemetry.yaml`. * Added native Copilot CLI spans over OTLP HTTP using W3C trace-context propagation, backed by a per-run protocol and endpoint latch that logs a warning if gRPC is used. - **Per-agent `settings_dir` on `claude-agent-sdk`** (#513) — selects which directory's `project` settings tier supplies an agent's **skills**, independently of `working_dir`. The CLI advertises exactly one MCP root — its cwd — and a filesystem MCP server that sees a Roots-capable client discards the directories in its own argv, so pointing `working_dir` at a target repository to pick up its skills also narrowed the agent's only MCP root onto it. `settings_dir` splits the two, letting cwd stay wide enough for every path the agent must read. It carries a second, unconditional effect: `add_dirs` widens the model's built-in `Read`/`Edit`/`Bash` to that tree regardless of any settings tier, though no Conductor configuration reaches a permission mode where that is observable today. Only the skills of that directory travel — not `CLAUDE.md`, `.claude/rules/*.md`, `.claude/settings.json` or `.claude/agents`, all measured. Refused at `conductor validate` *and* at run time on a provider that cannot apply it; a `settings_dir` whose `project` tier is not enabled warns in both places too, since the filesystem grant applies even when the skills half no-ops. Reported on the agent lifecycle events so the grant is auditable. See [`examples/claude-agent-sdk-settings-dir.yaml`](examples/claude-agent-sdk-settings-dir.yaml). ### Changed - **Claude default `max_tokens` raised from 8192 to 16384** when unset (#503). This doubles the worst-case output cost per call for users who never set it; set `runtime.max_tokens` explicitly to keep the former behavior. For Claude thinking agents, `low` or `medium` effort levels without an explicit `max_tokens` limit now send 16384 tokens instead of the former 8192 or 12288 tokens. - **The `openai` provider honors vendor-advertised token limits** (#503) from the models listing when available, using them to size the compaction output reserve. - **A `working_dir` or `settings_dir` template that renders empty is now an error** (#513). Previously an empty render resolved to the workflow file's own directory — `Path("")` is `Path(".")`, which is not absolute, so it was joined onto that directory and passed the existence check — and the agent ran there. A value meaning "nothing" silently becoming something real is the defect; for `settings_dir` it would also have granted the model access to the workflow's own tree. Both fields now fail before the provider call, naming the field and the template it came from. ### Fixed - **`openai`: retry transient errors delivered inside an SSE stream** (#506) — the OpenAI SDK raises a bare `openai.APIError` (no HTTP status) for an `error` object embedded in a stream, which pydantic-ai does not translate, so a configured `retry:` policy was skipped and the run failed after the first attempt. Now retried: OpenAI mid-stream 5xx (`server_error` / `internal_server_error`), OpenAI rate limits (`type` `requests` / `tokens` with code `rate_limit_exceeded`), Anthropic-shaped gateway errors proxied unchanged (`rate_limit_error` / `overloaded_error` / `api_error`), and stream errors with no parseable payload `type` (a non-object `error` value from an Ollama/vLLM gateway, or an Azure-style `{"code": ...}` shape), which are treated like broken streams. Still fatal: recognized client-side payload types (e.g. `invalid_request_error`) and every HTTP 4xx. Errors a narrowed `retry_on:` declines are now wrapped in `ProviderError` naming the declined category instead of escaping as raw SDK exceptions, a declined retry is logged at warning level (a taken one already was), and a fatal bare `APIError`'s message now carries the payload `type`/`code` the SDK leaves out of `str(e)`. - **Context compaction window guard against token-dense drift** (#507) — the `claude` / `openai` providers' compaction trigger anchors on provider-reported token usage and estimates everything after the anchor with a ~4-characters-per-token heuristic, which undercounts token-dense content (CJK and other non-Latin scripts, base64, hex, minified data) by 2-4x. A dense suffix could therefore grow the real request past a known context window while the trigger estimate stayed below the threshold, and the provider rejected the request with `context_length_exceeded`. A second, density-calibrated estimate now guards the hard window: it matches the primary heuristic on ordinary prose, counts text with a substantial non-ASCII share at ~1 token per character, and whitespace-poor ASCII blobs at ~2 characters per token, so it fires only on genuinely dense content — never on a history that is merely large. When it fires, the tier chain is driven directly against that measurement (the inner strategy's own gate would re-measure with the same heuristic that under-counted the content and no-op), until the estimate is back under the target. Telemetry stays on the token scale: `agent_compaction_start` gains `trigger_reason` (`"trigger"` / `"window_guard"`) and a separate `density_tokens` field instead of overloading `tokens_before`, and `agent_compaction_complete` gains `degraded_estimators` and `still_over_window` so a guard compaction that could not get back under the window reads as degraded, not as false success. A failed primary measurement falls back to an independent density-calibrated estimate that shares no code with it, and a double failure is reported as a new `agent_compaction_skipped` event (`reason: "estimate_unavailable"`) rather than vanishing into stderr. See [Workflow Syntax → Context Compaction](docs/workflow-syntax.md#context-compaction). - **Validator retries preserve the primary agent conversation** (#511) — when a semantic validator rejects output from the Claude, OpenAI, or Hermes provider, the correction now continues the completed agent conversation — the Pydantic AI message history for Claude/OpenAI, the run's own message list for Hermes — and sends validation feedback as the next user turn. This preserves prior reasoning and tool exchanges without repeating the original prompt, workspace instructions, or injected skills. A failed re-run now reports its cause on the `agent_validation_failed` event and in the console log, and the dashboard keeps the agent's original prompt visible instead of replacing it with the feedback-only turn. - **Concurrent agents no longer build duplicate provider instances** (#512) — resolving one provider type from two agents at once (a parallel group, or a `for_each` with `max_concurrent > 1`) was a check-then-act with an `await` between the cache check and the cache write, so each could construct its own instance and the second write replaced the first, leaving the two agents holding different objects for the same provider type. A waiter could also observe a provider before its restored resume-session state had been applied. Construction, resume-session wiring, and cache publication are now one operation under a registry-local lock that re-checks the cache; cached reads stay lock-free, a failed construction caches nothing and strands no waiter, and distinct provider types remain independent. - **A multi-line reply to a terminal dialog is now one turn** (#509) — dialog mode was the only free-text human-input surface that could not accept a multi-line answer (`QuestionDef.multiline` defaults to `True` and `GateOption.multiline` opts in, both served by one reader in `gates/human.py`). The dialog gate read a reply with single-line `Prompt.ask`, so pasting a block of text into an interactive terminal dispatched *each line* as its own turn: a three-line paste became three separate questions to the model, each answered against a fragment, and the paste's trailing newline added a fourth turn with empty content. Terminal turns now read through the multi-line reader already behind the human gate's `.` sentinel, submitted with `/send` on its own line, so internal newlines survive and a paste is a single message. An empty or whitespace-only submission is no longer dispatched as a turn. A dismiss keyword is recognised only once a turn is submitted, so on a tty `done` now needs `/send` after it, and both the opening banner and the failure-recovery notice say so rather than naming a keystroke that does nothing there. Ctrl-D at the start of a line (Ctrl-Z then Enter on Windows) also submits the lines entered so far, or dismisses the dialog when there are none. Because a terminal's EOF does not persist, abandoning a part-written reply that way now sends what was already entered and a second Ctrl-D is needed to leave, where one used to exit; on an empty prompt it still exits in one keystroke. The dialog uses `/send` where the human gate keeps `.`, since a lone `.` is likelier to be prose in a conversational reply. Off a tty — a pipe or CI — replies are still read one line at a time and `/send` has no effect; the one change on that path is that a blank line is now skipped instead of dispatched as an empty turn. The web dashboard is unaffected: it takes a separate path that already delivered each message whole. ## [0.1.36](https://github.com/microsoft/conductor/compare/v0.1.35...v0.1.36) - 2026-09-02 ### Added - **`conductor mcp serve`** (#432) — exposes your registered Conductor workflows as [MCP](https://modelcontextprotocol.io/) tools to any MCP-compatible host (Claude Code, VS Code, Cursor, etc.) over stdio, with no workflow edits required: every workflow in every configured registry is exposed by default, with a typed `inputSchema` derived from its own `input:` block. A tool call always forks a real detached `conductor run` — the server never executes a workflow in-process — and by default **returns immediately** with a run handle carrying the `run_id`, dashboard `url` and `port`, the captured log paths, and the `conductor fleet` / `conductor status` commands for watching it from a terminal, so the caller can report the run back and move on while it keeps going. A caller may opt into a bounded wait per call (`_wait_seconds`, capped by `--max-wait-seconds`), which changes only whether *that call* blocks — never how the workflow runs; start the server with `--max-wait-seconds 0` to make every invocation non-blocking regardless of what a caller requests. A run that has not completed (immediate, at-gate, failed, or timed-out) returns the handle; a run that completes within a bounded wait returns its output inline, or — once serialized `output:` exceeds 50 KB — spilled to a file with a `resource_link` and no dashboard `url`. New `conductor_run_status` / `conductor_await_run` / `conductor_cancel_run` / `conductor_list_runs` tools answer for a `run_id` before, during, at a human gate, and after a run has finished — the human gate is never auto-skipped; a run that reaches one parks and reports its dashboard approval URL until a person resolves it. Optional `introspect`/`diagnose` toolsets (off by default; enable with `--toolsets`) add event-query, per-step detail, `conductor doctor`/`conductor validate` equivalents, and links (never file contents) to a run's raw logs. `--allow`/`--deny` narrow or force the exposed set; a registry above `--max-direct-tools` (default 25) degrades to a two-tool discovery pair instead of failing or overflowing a host's tool-count limit. See [`docs/mcp-server.md`](docs/mcp-server.md) for the full guide, including a dedicated *Limits* section for what this release deliberately does not do (no `outputSchema`, no Streamable HTTP transport, tool call payloads withheld unless `--introspect-full`). - **`workflow.mcp:` block** — per-workflow configuration read by `conductor mcp serve` to decide how a workflow is exposed as an MCP tool: `expose` (default `true`), `mode` (`async`/`sync`/`auto`), `read_only`, `destructive`, and `estimated_minutes`. Every field defaults to the value that keeps an existing workflow with no `mcp:` block at all exposed identically to one that declares the defaults explicitly, so no existing workflow needs editing. An unknown key inside the block is a `conductor validate` schema error, not a silently ignored typo. See `examples/mcp-serve.yaml`. ### Changed - **`conductor status` and `conductor fleet list` now also list recently-completed runs, not just currently-running ones — a contract change to what these commands mean.** Previously both meant "runs alive right now"; a finished run disappeared the moment its process exited. Each command now renders (or, for `status --json`, returns in an additive `completed` array) a bounded set of recently-completed runs with their terminal status (`completed`/`failed`), when they ended, duration, tokens/cost, and error type for a failure — sourced from the terminal run record every run now writes on exit. `conductor fleet list`'s completed rows are bounded by `[fleet.retention].keep_last`. Both commands remain read-only: listing a completed run never removes its terminal record. Pass `--live` to either command to restore the exact previous scope (`status --json --live` also drops the `completed` key from the payload entirely, so an existing scripted consumer of `payload["running"]` is otherwise unaffected by this change). The Fleet Manager TUI's History screen also gained a failed run's error message and a completed run's rendered output, reachable by selecting a row, without adding a new column to its table. ### Fixed - **The `mcp` SDK dependency is now bounded below its breaking 2.0 release** (`mcp>=1.28.1,<2`). `mcp` 2.0.0 renamed the camelCase attributes the existing MCP client reads (`Tool.inputSchema` -> `input_schema`), so an installation whose lock had already floated to `mcp` 2.x had a client that connected to a server and then raised `AttributeError` on every tool listing — MCP tools were silently non-functional. Re-locking with this bound restores them; the pin does not change behavior for anyone already on `mcp` 1.x. ## [0.1.35](https://github.com/microsoft/conductor/compare/v0.1.34...v0.1.35) - 2026-08-28 ### Removed - **Dead workflow lifecycle hooks (`on_start` / `on_complete` / `on_error`)** (#476). The `hooks:` block was parsed and its templates rendered, but the result was discarded — never emitted as an event, logged, shown, stored, or used for any side effect — so the feature was entirely unobservable, including when a hook failed. `HooksConfig`, `WorkflowDef.hooks`, the engine's `_execute_hook` / `LifecycleHookResult` and all call sites, and the Hooks section of `docs/workflow-syntax.md` have been removed. A workflow that still declares `hooks:` now fails validation with a clear error rather than silently ignoring the block. Lifecycle hooks may return later, but the right syntax will be designed against a concrete requirement (emitting an event, invoking a `type: script` step, or calling a webhook) rather than rendering a template and throwing it away. ### Fixed - **`conductor doctor`'s table output no longer dies part-written on a `cp1252` console** (#401). The Installed/Credentials/Connection/Models columns hardcoded `✓`/`✗`/`○`/`⚠`, none of which cp1252 can encode, so a run on a legacy Windows console raised `UnicodeEncodeError` mid-table, after the Environment section had already printed. `conductor doctor` now resolves each glyph once per invocation against the output console's stream encoding, falling back to `OK`/`X`/`o`/`!` when the Unicode glyphs cannot be encoded; the `--json` path was already safe and is unchanged. - **Plugin flavor resolution (Claude vs. Copilot builds)** (#497). A Claude-built plugin's `agents/*.md` subagents (no `.agent.md` suffix) were silently never loaded — the candidate-file rule was hardcoded to the Copilot build's convention. Flavor is now read off the manifest that actually matched and threaded as a tie-break-only axis through plugin resolution, so `provider: copilot` agents using a Claude-built plugin now get its subagents too. Also adds `~/.copilot/settings.json` marketplace resolution as a fallback for `plugin@marketplace` references, and several new non-fatal warnings when a build cannot be determined unambiguously. ## [0.1.34](https://github.com/microsoft/conductor/compare/v0.1.33...v0.1.34) - 2026-08-24 ### Added - **Native OpenAI provider** — new stable `openai` provider built on the shared Pydantic AI runtime. Works with the real OpenAI API and any OpenAI-compatible Chat Completions endpoint (Ollama, vLLM, LM Studio, OpenRouter, corporate proxies). Supports MCP tools, structured output, interrupts, reasoning effort (`low`/`medium`/`high`), and the full `0.0`–`2.0` temperature range, which is now expressed as `ProviderCapabilities.max_temperature` and enforced in `create_provider` so `conductor run` and `conductor resume` are covered rather than only `conductor validate`. See `docs/providers/openai.md` and `examples/openai-compatible.yaml`. A custom `base_url` requires an explicit `api_key`: an ambient `OPENAI_API_KEY` is never forwarded to a non-OpenAI endpoint. - **Fleet TUI launch directory** (#477) — `conductor fleet` can now start runs in a directory other than the one it was itself launched from. `d` on the Runs screen (or `ctrl+d` on New run) opens a directory picker; the chosen directory is the base a relative workflow reference on the New Run screen resolves against, and the working directory that a launched or resumed run's detached child inherits. It is process-lifetime only — there is no `config.toml` key and no state file, and it resets when `conductor fleet` exits. It does not affect `runtime.working_dir` / `agent.working_dir`, and it is not a filter: Runs and History still show the whole fleet. See `docs/fleet.md`. - **`runtime.idle_timeout_seconds` / `runtime.max_idle_recovery_attempts`** (#488) — Copilot-only knobs to tune the idle watchdog for workflows with legitimately long tool calls. `idle_timeout_seconds` sets the time without SDK events before a session is treated as idle (default 90s); `max_idle_recovery_attempts` caps the number of "please continue" prompts sent before failing (default 5; `0` fails on the first genuine idle without ever injecting a prompt). See `docs/configuration.md` and `docs/workflow-syntax.md`. ### Changed - The Pydantic AI dependency was narrowed from the full `pydantic-ai` package to `pydantic-ai-slim[anthropic,openai]`. This drops the bundled `pydantic_ai.mcp` module, which Conductor replaces with its own toolset bridge, so the change is transparent to users. - The previously reserved `openai-agents` provider name has been removed from the schema, factory, registry and diagnostics. Workflows that named it now fail at schema load time rather than at the first agent execution. ### Fixed - **The Copilot idle watchdog no longer fires during long-running tool calls** (#488). The SDK does not guarantee any events during a tool call — `tool.execution_progress` / `tool.execution_partial_result` exist in the SDK schema but are opt-in per tool, so for most tool calls nothing arrives between `tool.execution_start` and `tool.execution_complete` — so a stale idle clock while a tool was still executing was previously indistinguishable from a genuinely stuck session — triggering a spurious "please continue" recovery prompt mid tool-call. That prompt's conversational reply then overwrote the agent's eventual structured output (`response_content` is last-message-wins), turning a healthy run into a non-retryable failure. In-flight tool calls (tracked by `tool_call_id`) now suppress idle recovery entirely while any remain outstanding; `max_session_seconds` is the sole backstop for a genuinely wedged tool. Recovery-prompt and stuck-session messages also no longer misattribute the failure to a tool that has already completed — `last_activity_ref`'s tool name is now cleared (or rolled to another still-in-flight tool) on `tool.execution_complete` instead of only ever being set. The first occurrence of extended suppression during a session is logged at `warning` level (naming the in-flight tools and the `max_session_seconds` backstop); further occurrences in the same session are debug-only. - Retry classification now covers the `ModelHTTPError` and `ModelAPIError` types pydantic-ai actually raises, so `408`, `429` and `5xx` responses are retried on the Claude provider as well as the new OpenAI one. Previously they were treated as fatal. - `runtime.default_reasoning_effort` was silently dropped at run time for every provider and is now forwarded through `ProviderRegistry`. - **MCP tool discovery and structured tool results no longer break with MCP 2.0** (#419). MCP 2.0 renamed the Python field on `mcp.types.Tool` from `inputSchema` to `input_schema` and on `mcp.types.CallToolResult` from `structuredContent` to `structured_content`, retaining the camelCase name as the serialization alias in both cases. The second rename failed quietly: a tool returning only structured content raised `AttributeError`, which was wrapped into a `RuntimeError` the model read as an ordinary tool failure. Conductor now reads both fields through a shared helper that tries the 2.x name and falls back to the 1.x one, preserving compatibility with both MCP 1.x and 2.x. - **The Fleet Manager TUI's launch-directory picker no longer clobbers its own prefill** (#486). Textual posts a `NodeHighlighted` event for the directory tree's own root at mount, from reactive initialisation, with no user interaction involved; `DirectoryPickerModal` mirrored every such event into the input, silently replacing the prefilled launch directory with its parent before the user ever touched the tree. The mirror now fires only while the tree actually has focus. - **The Fleet Manager no longer loses data from large event logs** (#485). The Runs, History, and run-detail screens read a run's JSONL event log through three separate bounded windows — a 512 KiB tail, a 512 KiB head recovery read, and an 8 MiB whole-log cap — that a long-lived or resumed run outgrows. On a real 9.72 MB / 20,361-line log this lost the current step and the token/cost totals, and a resumed run's second `workflow_started` fell outside the head window, so the wrong workflow topology was reported. All three windows are replaced by one streamed reader bounded only by the longest individual line, and a resumed run's totals now accumulate across generations while its status, gate, and topology reflect the current attempt. The Runs screen's ~2s poll prefilters lines by event type before parsing them, so the uncapped read is also faster than the capped one it replaces. - **A run record could silently fail to be removed on Windows** (#486). `remove_run_record` deleted a record with a single unretried `unlink`, and `remove_run_record_for_current_process` renamed it into a quarantine path with a single unretried `rename`; on Windows, a concurrent reader can make either fail with a sharing violation, leaving a stale record behind. Both paths now use the same bounded retry that `write_run_record` already used for its own `os.replace`. - **The Copilot provider now recovers automatically when its nested runtime process dies** (#483), instead of retrying against a dead process with a misleading "Check that copilot CLI is installed and authenticated" error. A dead spawned runtime is now detected via `subprocess.Popen.poll()` on the SDK's own child handle and via explicit recognition of `BrokenPipeError` / `ConnectionResetError` at the agent-execution SDK boundary (including during idle-recovery "continue" prompts, which previously burned every recovery attempt and were reported as a stuck *agent* rather than a dead *process*). Recovery rebuilds the SDK client the next time it is needed, so the existing retry loop lands its next attempt on a fresh runtime with no change to retry-loop shape; a runtime that keeps dying without a single successful call in between fails fast after 2 consecutive restarts (a fixed, non-configurable cap — with the default `max_attempts` of 3, a single agent execution can only trigger 2 restarts on its own, so the cap mainly bites across agents in the same workflow) rather than looping forever, while a long-running, otherwise-healthy workflow can restart it as many times as needed. A broken connection to an **externally-owned** runtime (`runtime_url` / `COPILOT_PROVIDER_RUNTIME_URL`) is treated differently: it is never retried or respawned, since the orchestrator that owns that runtime is responsible for its health checks and restarts. ## [0.1.33](https://github.com/microsoft/conductor/compare/v0.1.32...v0.1.33) - 2026-08-18 ### Added - **The Fleet Manager TUI's History screen can now resume a run** by pressing `r` on a row that correlates to an on-disk checkpoint, launching `conductor resume --web-bg` in the background the same way the New Run screen launches a fresh workflow. Gating is checkpoint-driven, never derived from the row's outcome — an `unknown` row (no terminal event) offers Resume exactly like a `failed` one when a checkpoint exists for it, though this only applies when the workflow opted into periodic checkpoints (`runtime.checkpoint`) or failed and left a failure checkpoint behind. A currently-live run is always excluded, regardless of outcome or checkpoint — resuming a run that is still executing would make the new process adopt the original `run_id`, overwrite its run record, and interleave two processes' events into one log. See [`docs/fleet.md`](docs/fleet.md). - **Session continuity for the `claude-agent-sdk` provider via a per-agent `session_key`** — executions tagged with the same key now continue one Claude session instead of each starting cold, so an investigate → check → retry loop keeps what it already read, and a later agent can inherit an earlier one's conversation by declaring the same key. The key is a static, unrendered label; sessions are scoped per working directory, since that is how the `claude` CLI stores transcripts. The map is persisted in checkpoints, so continuity survives `conductor resume`, and the new `session_continuity` capability turns `session_key` against a provider that cannot honor it into a `conductor validate` error rather than a silently dropped setting. A session the provider cannot confirm on disk logs a warning and starts fresh rather than failing the run, and `conductor validate` refuses a key shared across concurrent executions. See [`docs/workflow-syntax.md`](docs/workflow-syntax.md#session-continuity-session_key) and [`examples/claude-agent-sdk-session-key.yaml`](examples/claude-agent-sdk-session-key.yaml). - **Checkpoints now persist every active provider's session map**, rather than stopping at the first provider that exposes one. A workflow mixing providers previously kept only one map, silently dropping the others' sessions depending on which agent happened to run first. `claude-agent-sdk` namespaces its own entries, so they cannot collide with Copilot's agent-name keys in the merged map. - **Fleet Manager TUI: RDP session detection turns animation off automatically** (issue #462). An RDP session (`SESSIONNAME` starting `RDP-Tcp`) now disables the ~10fps animation clock by default — the same repaint that made the TUI feel laggy over that transport. SSH is deliberately *not* detected: it ships the ANSI byte stream for the local terminal to render (a few hundred bytes per frame), where RDP renders remotely and ships changed pixel regions, so only the latter is costly in practice. `CONDUCTOR_FLEET_NO_ANIM` remains the remedy for a genuinely slow SSH link and for transports with no reliable signal (VNC, Citrix, xrdp). The existing `CONDUCTOR_FLEET_NO_ANIM` force-off switch still wins over detection, and a new `CONDUCTOR_FLEET_ANIM` force-on switch overrides detection when the operator knows the link can take it. Any path that disables animation — explicit `CONDUCTOR_FLEET_NO_ANIM` or detection — now also sets Textual's own `App.animation_level` to `none`, which additionally stops Textual's built-in widget animations (e.g. the tables' smooth-scroll easing); this is a behavior change for existing `CONDUCTOR_FLEET_NO_ANIM` users, not only for the new detection path. See [`docs/fleet.md`](docs/fleet.md#animation-and-remote-sessions). ### Changed - **`runtime.skill_injection.max_bytes` now defaults to 160KB, up from 128KB.** The bundled `conductor` skill has grown to ~132KB, so the old ceiling no longer sat above it: a `claude` or `hermes` agent enabling the shipped skill would have failed outright instead of warning, which is the opposite of what the two defaults are for. The 64KB `warn_bytes` default is unchanged, so that combination still warns. Workflows that set `max_bytes` explicitly are unaffected. - **`examples/wait-smoke.yaml` now caps itself at `timeout_seconds: 15`, up from `3`.** It doubles as CI's `--web-bg` launcher smoke fixture, and a cold Windows runner spends seconds of that budget on process and step overhead — so a cap sized for the ~1s the workflow actually waits reported a slow runner as a launcher failure. The timeout path it demonstrates is unchanged; drive it with a larger `--input middle_duration_ms`. ### Fixed - **Fleet Manager TUI: the ~10fps animation tick no longer repaints the preview pane and footer** (issue #462). `RunsScreen._tick` used to end by calling `_update_gate_detail()`, rebuilding the whole preview `Text` and re-evaluating the footer's key bindings ten times a second for the sake of one spinner glyph — over RDP this made the whole TUI feel laggy. The preview pane is now split into `#run-preview` (the gate section and progress header, rebuilt on data/selection changes only) and `#run-preview-score` (the flowed step chips, the only part that actually animates); the frame tick now only repaints the latter, alongside the animated table cells it already updated. See [`docs/fleet.md`](docs/fleet.md#animation-and-remote-sessions). - **`claude` provider: `validate_connection()` no longer fails startup when an Anthropic-compatible endpoint doesn't implement `models.list()`** (issue #455). Azure AI Foundry's Anthropic endpoint, and some LiteLLM/Databricks AI Gateway configurations, answer `/v1/models` with a 404 while `/v1/messages` (what agents actually call) works fine — previously this made every workflow using such an endpoint fail before running a single agent. The startup probe now only fails on positive evidence of a broken setup: an unreachable host, rejected credentials (401/403), or a non-HTTP error. Any other HTTP status logs a warning naming the status code and continues, deferring credential verification to the first agent execution — the same posture the `hermes` provider already documents. See [`docs/providers/claude.md`](docs/providers/claude.md#startup-connection-validation). - **A step with no model no longer constructs a provider just to report a context window.** Every step type emitted `agent_started` with a `context_window_max` resolved through the provider, and the registry builds providers lazily — so a `wait`, `set`, `script`, `terminate`, or `human_gate` step built an SDK client whose only possible answer was `None`. That construction runs inside the engine's timed loop, so it was charged to `limits.timeout_seconds`: a provider-free wait workflow paid ~0.4s of it locally and enough on a cold Windows CI runner to time the workflow out and fail the `--web-bg` launcher smoke job. Provider-backed agents are unaffected — they still report the window on both `agent_started` and `agent_completed`. - **Fleet Manager TUI: the footer now says what `enter` does on each screen** (issue #459). Every drill-down screen bound `enter` but left it unlabeled, so the one key that navigates the TUI was the one key the footer never advertised — Runs opens the run detail, Run detail opens the step detail, History surfaces the `conductor replay` command, Providers expands or collapses a provider, and Registries opens that registry's workflows. The binding is also hidden whenever it would do nothing: an empty, failed, or still-loading table, or a Providers sub-row that is not a provider. Expanding a provider a second time now collapses the provider you were actually on rather than whichever row the rebuild left under the cursor. See [`docs/fleet.md`](docs/fleet.md). - **The Pydantic AI provider (`claude`) never retried on HTTP 429/5xx or transport errors** (#454). pydantic-ai's Anthropic model translates the SDK's exceptions before Conductor ever sees them (a private helper, `_map_api_errors` in pydantic-ai 2.x, written inline at the 1.44.0 floor) into `ModelHTTPError` (for an HTTP error response) and `ModelAPIError` (for a connection/timeout failure), so neither the SDK class names nor the `anthropic.APIStatusError` check that `_is_retryable_error` relied on ever matched — every attempt failed fast as a non-retryable error regardless of `retry:` configuration. Both translated types are now classified directly, matching the existing 429/5xx retryable set, and a server's `retry-after` value is recovered from `__cause__` (the translation drops response headers, but preserves the original SDK exception there) or from the response body. - **A per-agent `retry.delay_seconds` larger than the 30s provider default was silently clamped back down to 30s** on both the Pydantic AI (`claude`) and Copilot providers, so `delay_seconds: 60` produced 30s waits instead of the stated 60s. The internal backoff cap is now `max(default_max_delay, delay_seconds)`, so a larger stated delay raises the cap instead of being clamped by it; existing configurations with `delay_seconds` below the default are unaffected. ## [0.1.32](https://github.com/microsoft/conductor/compare/v0.1.31...v0.1.32) - 2026-08-16 ### Fixed - **The `--web-bg` launch gate now terminates the whole workflow process tree, not just the pid it spawned, closing the orphan a trampoline `sys.executable` could leave behind** (#447). Issue #444 fixed the launch gate's false-positive port conflicts but left its four failure paths terminating only `subprocess.Popen.pid` — under a trampoline `sys.executable` (e.g. a Windows `uv tool install`, the documented install path), that pid is a re-exec shim, not the process actually running the workflow, so a launch-gate failure could kill the shim and leave the real workflow running, undiscoverable, and still burning tokens. On Windows the child is now created suspended and assigned to a fresh job object *before* it can run (so it cannot re-exec out of reach), with `TerminateJobObject` reaching the whole tree regardless of exec depth; the job deliberately has no `JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE` so the tree still survives the launcher exiting, which is the entire point of `--web-bg`. On POSIX, `os.killpg` now reaches the process group the detached child already leads. After the tree kill, a final liveness sweep independently confirms every pid the gate knew about is actually dead rather than assuming it — a survivor is now named explicitly in the error message (with a `conductor status` / `conductor stop --port` pointer) instead of the message unconditionally claiming "The background process was terminated." A run record is only removed once its pid is confirmed dead by that sweep, so a surviving orphan keeps the record that is `conductor stop`'s only remaining handle on it. - **`--web-bg` no longer fails on every port with a false "Port already in use", killing a healthy run** (#444). The launch gate's two identity checks both compared against the *spawned* process's pid (`subprocess.Popen.pid`), which is not always the pid of the process that ends up running the workflow: on a trampoline `sys.executable` (e.g. a `uv tool install` on Windows, the documented install path) the spawned process re-execs into a different one. That made the run-record poll (stage one-and-a-half) never see its own child's record — surfacing as "did not report a run record within 15 seconds, but is still running" — and then made stage two's `/api/info` probe report every port as held by a foreign process, terminating the healthy child. The run-record poll now also accepts a record whose `pid` differs from `Popen.pid` when the record is *fresh* (written at or after this launch spawned its child), and carries the record's real `pid` forward as the confirmed identity for stage two. A `PORT_CONFLICT` is now only raised when that identity was confirmed; an unconfirmed mismatch degrades to the existing non-fatal "still initializing" note instead of ever being fatal. The `PID unknown` wording seen alongside the conflict is fixed too — the foreign pid is now captured before the child is terminated instead of probed after, when it can no longer answer. - **The Fleet Manager TUI no longer appears to freeze while a modal is open** (#448). Opening the gate options modal (`g`) left the Runs screen animating underneath it — a covered screen is still composited, so its ~10fps repaints kept re-blending the modal sitting on top. Measured on one 160x45 terminal at an open gate, that was roughly 2.5x the escape sequences and ~40% more CPU than the same screen with no modal up. On a terminal that cannot absorb that stream — over SSH, in a multiplexer, on a slow emulator — keystrokes queued behind the redraw and the modal appeared frozen. The animation is now suppressed while a screen is covered and its timer paused, which also stops the Runs screen animating under the splash, run-detail, history, providers, registries, and new-run screens. The ~2s data poll is deliberately left running, so gate-entry and run-failure notifications still fire while a modal is up. The empty-fleet state also no longer pairs "no runs" with a preview pane still offering `g` for a run that had gone. - **The Fleet Manager TUI's kill confirmation prompt is no longer an empty red box** (#449). `#confirm-dialog` had `width: auto` while both of its children fell back to Textual's base `1fr`, and an auto-width container whose children are all `1fr` resolves to zero — so the dialog collapsed to 0x0 and painted nothing but its border, leaving `k` looking like a broken no-op with no way to see what was about to be killed. The dialog now has a fixed width (capped at 90% of the terminal so it still fits a narrow one), its message scrolls instead of overflowing or being silently truncated, and the confirm/cancel hint is docked to the bottom so a long message cannot push it off screen. - **Fleet Manager TUI no longer blocks the Textual event loop on the Runs screen's ~2s poll, the run-detail screen's poll, History's initial load, or opening a run's dashboard** (#437). Each screen's data load now runs in a worker thread (`asyncio.to_thread`), with rendering back on the event loop, so the UI stays responsive on a large fleet or a slow filesystem (e.g. a WSL dashboard-open call that can take up to 15s). A tick arriving while the previous scan is still running is skipped rather than started alongside it, and each screen shows a brief "Loading…" line while its first result is in flight. An *explicit* refresh — after a kill, or after a gate is resolved — is coalesced rather than skipped, so those actions still update the table without waiting out a poll interval. - **The Fleet Manager TUI now tells you when it cannot read a run**, instead of showing something that looks like success (#437 review). A run-record directory it cannot read is reported on the Runs screen rather than leaving a "Loading…" line that never resolves or a table silently frozen at its last good contents; a fleet whose summaries all fail to derive is reported as an error rather than as the "no runs — launch one" empty state, which invited launching a duplicate of a workflow that was still running; and a History read failure is reported rather than rendered as "No run history yet.", which claimed absence and, since that screen loads once, never corrected itself. A run whose summary fails to derive on one poll tick also no longer loses its notification history, which had made it re-fire its gate/failure terminal notification on the next successful tick. ## [0.1.31](https://github.com/microsoft/conductor/compare/v0.1.30...v0.1.31) - 2026-08-15 ### Added - **Install scripts now diagnose a blocked package index instead of retrying into a generic failure.** On networks that block direct access to the public Python package index — increasingly common on managed corporate devices — `uv tool install` fails with a fetch/403/DNS-shaped error. uv has already exhausted its own retries by that point, so both scripts spent their 2s/5s/10s backoff on a failure that cannot heal, and `install.ps1` then printed file-lock advice (including a Windows Defender exclusion suggestion) that is both useless and misleading for a network-policy block. Both scripts now classify the failure, stop after the attempt that hit it, and explain the actual remedy: point uv at your organization's index with `UV_DEFAULT_INDEX`. They also echo the active index at install time — with any credentials in the URL redacted — so "did my override apply?" is answerable from the install log. On the blocked-index path `install.ps1` no longer reaches its Defender advice. - **Two neighbouring failures are told apart rather than blamed on the index.** uv words an unreachable *git remote* exactly as it words an unreachable index, and the installer fetches Conductor itself from `git+https://github.com/...` — so a blocked `github.com` was being reported as a blocked package index, sending users to configure something that could not help. It now gets its own message. Separately, connection-level blips (`connection reset` and friends) still get the full retry schedule, since unlike a policy block they can genuinely heal; only a definitive block short-circuits the retries. - **README: "Installing behind a proxy or private package index"** — how to install through a mirrored/proxied index with uv (`UV_DEFAULT_INDEX`, `uv.toml`, named-index credentials, TLS inspection, proxies) and with pip/pipx, including the trap that **uv does not read pip's configuration**, so `pip config set global.index-url` alone has no effect on the install scripts, `uv tool install`, or `conductor update`. Conductor ships no default mirror and never redirects package resolution on its own; the index is always user-supplied configuration. ### Fixed - **`--web-bg`/`resume --web-bg`: a failed run-record write no longer kills a healthy background workflow** (#435). The launch gate's run-record poll (Fleet Manager D2) used to terminate the child and fail the launch if it couldn't confirm the run record within 15 seconds, even when the child was alive and its dashboard was still reachable — treating a bookkeeping failure as a workflow failure. It now downgrades to a warning (`BackgroundLaunch.run_record_written=False`, surfaced via a new note pointing at the captured stderr log, and via a TUI notification from the Fleet Manager's New Run screen) and lets the launch proceed; only a child that is actually dead, or whose dashboard has gone unreachable, still fails the launch. - **The `run_id` format is now defined once**, in a new leaf module `conductor.run_id` (#435). Previously `fleet/records.py` enforced a broad path-safe pattern while `engine/event_log.py` independently enforced a narrower hex-only pattern and lowercased its input; a resumed `--web-bg` run whose checkpoint `run_id` contained uppercase characters could be silently folded to a different value by the event log, causing the parent's launch-gate poll to look for a key the child never wrote and kill the resumed run 15 seconds after a successful start. `fleet/history.py` and `fleet/retention.py`'s filename parsers, and `fleet/records.py`'s own timestamp parser, now derive their run-id-matching regexes from the same shared pattern. - **Install hints for optional extras now print a command that works, and upgrades stop uninstalling the extras you have** (#441). Every hint pointing at an optional extra hardcoded `pip install 'conductor-cli[]'`, which cannot work on the documented install path: `install.sh`/`install.ps1` create a `uv tool` venv, which is not pip-managed, and `conductor-cli` is not published to PyPI so pip has nothing to resolve against there. `conductor fleet` without the `tui` extra, and the `aca` / `claude-agent-sdk` provider errors, now resolve the command from the *detected* install context — `uv tool install --force ''` for an install-script install, `uv sync --inexact --extra ` for a source checkout, and `pip install` as the fallback, carrying the git URL you installed from when there is one so a `pip`/`pipx`-from-git install resolves too. The suggested command reuses the install source recorded for your install (so a fork or a local build is not redirected upstream) and carries the extras you already have, because `uv tool install --force` replaces the tool's entire requirement set and `uv sync` is exact by default. A receipt that cannot be read is reported rather than treated as "no extras" — in the hint, and in both install scripts, which warn and carry on rather than either dropping the extras silently or refusing to run. For the same reason, `install.sh` and `install.ps1` now read the existing install's `uv-receipt.toml` and rebuild the source as `conductor-cli[] @ `, so `conductor update` (which drives them) no longer silently uninstalls `[tui]` or `[aca]` on upgrade — it also names the extras it found before you commit. New `--extras ` / `CONDUCTOR_INSTALL_EXTRAS` adds an extra during an install or upgrade (rejecting one this package does not declare, which uv would otherwise accept with a warning and a zero exit status), and `--no-preserve-extras` / `CONDUCTOR_INSTALL_NO_PRESERVE_EXTRAS` drops back to a bare install. - **Fleet Manager History no longer accumulates an entire retained event log into memory to build one entry** (#436). `_read_full_log` now streams parsed events one at a time instead of materializing them into a list before scanning, so building a History entry from a large `*.events.jsonl` file no longer holds the whole parsed log in memory at once. ## [0.1.30](https://github.com/microsoft/conductor/compare/v0.1.29...v0.1.30) - 2026-08-14 ### Added - **Fleet Manager: `conductor stop`, `conductor fleet list`, and a new interactive `conductor fleet` TUI now discover every run, not just `--web-bg` ones** (#431). Previously only `--web-bg` wrote a discoverable (port-keyed `.pid`) record, so a plain `conductor run` or `conductor run --web` process was invisible to `conductor stop` and had to be killed by hand. Every run path now writes a `run_id`-keyed JSON record to `~/.conductor/runs/.json` describing its mode (`fg`/`fg-web`/`bg`), PID, workflow path, and dashboard port (when it has one); `stop`, `fleet list`, and the TUI all read from this same store. The legacy port-keyed `.pid` file is still read (and cleaned up) for a still-running pre-upgrade process, but is no longer written by any current code path. **Behavior change:** stopping a **foreground** run (`mode` `fg`/`fg-web` — anything holding a terminal) now requires interactive confirmation, since a plain `SIGTERM` discards in-flight progress unless periodic checkpoints are enabled for that run; a background-only fleet is unaffected. Use `--yes`/`-y` to skip the prompt (e.g. scripts, CI); a non-interactive `stdin` without `--yes` refuses to proceed rather than silently defaulting to "yes". `stop` also gained `--run-id`, the only selector that can target a foreground run with no dashboard port to match on. See [`docs/cli-reference.md`](docs/cli-reference.md#conductor-stop). - **`conductor fleet`** (#431) — an optional interactive Textual TUI (`pip install 'conductor-cli[tui]'`) for monitoring, managing, and launching Conductor runs across dedicated screens: Runs (home, ~2s-polled, sorted by recency), Run detail (per-agent topology and timings, not a DAG), Providers (collapsed-by-default provider/model diagnostics, reusing `providers/diagnostics.py`), Registries (registries → workflows → inputs), New Run (form generated from a workflow's declared `input:`, launches via the same `conductor run --web-bg` path the CLI uses), and History (every retained run regardless of outcome, bounded by retention plus an independent 200-entry display cap, delegating replay to `conductor replay ` rather than re-implementing it). A human gate is displayed as a persistent badge for every run mode; it can additionally be **resolved** from the TUI (`g`) for any run with a dashboard port (`fg-web`/`bg`) via the existing `conductor gate respond` HTTP path — a plain foreground run's gate is display-only (its PID is shown) since its blocking prompt thread cannot be reached remotely. A terminal bell / OSC 9 notification fires once per transition into `at-gate` or a failure. `conductor fleet list` and `conductor fleet prune` need no optional dependency; only the bare, no-subcommand `conductor fleet` (which launches the TUI) requires the `tui` extra. See [`docs/fleet.md`](docs/fleet.md). - **`~/.conductor/config.toml`** (#431) — a new machine-wide, read-only-in-v1 settings file (`src/conductor/settings.py`), read with stdlib `tomllib` and honoring `$CONDUCTOR_HOME` the same way `registries.toml` does. Currently controls `[fleet.retention]`: an opportunistic sweep (`enabled = true` by default, `keep_last = 200`) that bounds the otherwise-unbounded `$TMPDIR/conductor/` directory of event logs at the start of every `conductor run`/`resume`. Never deletes the `checkpoints/` subdirectory or an event log a live/resuming run still references. `conductor fleet prune` is the explicit manual entry point (with `--keep-last`/`--dry-run`) and always works regardless of the `enabled` setting. A missing file is normal (every setting defaults cleanly); a malformed file only breaks an explicit reader (`fleet prune` with no `--keep-last` override) — never `conductor run`/`resume`, which swallow a settings load failure and just skip the feature it configures. See [`docs/configuration.md`](docs/configuration.md#machine-wide-settings-conductorconfigtoml). ### Changed - **`workflow_started` now records the run's resolved `inputs`** (#431). Two runs of the same workflow are otherwise indistinguishable in a listing. The values are written to the run's JSONL event log, which is also read by `conductor replay` and the dashboard. ### Fixed - **`conductor stop` against a foreground run is no longer a silent no-op** (#431). With the interactive keyboard listener active, the `SIGTERM` handler delegated to the previous disposition only when it was *callable* — and in an unmodified process `signal.getsignal(SIGTERM)` returns `SIG_DFL`, an `IntEnum` member that is not callable, so the signal fell through and was swallowed entirely: the process survived and kept running. The handler now restores the default disposition and re-raises against itself. An inherited `SIG_IGN` is honoured rather than converted into a termination. - **A `questions` node no longer leaves the run parked at an already-answered gate** (#431). A questions node reuses `gate_presented` but never emitted the matching `gate_resolved`, so every consumer of the event stream — the web dashboard as well as the Fleet Manager — held a gate that never closed for the remainder of the run. ## [0.1.29](https://github.com/microsoft/conductor/compare/v0.1.28...v0.1.29) - 2026-08-13 ### Security - **Hardened the web dashboard's HTTP/WebSocket surface** (#397). Every mutating route (`POST /api/stop`, `/api/kill`, `/api/resume`, `/api/gate-respond`, `/api/guidance`) and the `/ws` handshake now require a per-run token by default — previously the only protection was the optional `CONDUCTOR_GATE_TOKEN` env var, and requests were unauthenticated when it was unset. The token is minted automatically per run and discoverable by `conductor gate respond` / `guide` / `stop` via a new `0600` file (POSIX; on Windows the mode bits are not honoured and the file relies on the user-profile ACL instead — see #425) at `~/.conductor/runs/dashboard-.token`; `CONDUCTOR_GATE_TOKEN` still overrides it when set. A new pure-ASGI `OriginHostGuard` middleware also validates the `Host` and (when present) `Origin` headers on every HTTP and WebSocket request, closing the DNS-rebinding and CSRF-from-another-open-page angles; `CONDUCTOR_WEB_ALLOW_ORIGINS` (comma-separated origins) extends the allowlist for local dev servers. **Breaking for external API callers:** every mutating route now also requires `Content-Type: application/json` (415 otherwise), including the previously bodyless control POSTs, and a request whose `Host`/`Origin` doesn't match the bound dashboard is rejected with 403 regardless of token. Read-only routes (`/api/state`, `/api/info`, `/api/logs`, `/api/gate-status`, `/api/files/*`, and the replay dashboard) remain unauthenticated, protected by Origin/Host only. - **Hardened the ACA agent runner's transport surface** (#396). The experimental `aca` provider's in-container runner previously relied entirely on the Azure session-gateway network boundary; it now adds four independent layers, none individually load-bearing. The runner binds `127.0.0.1` by default (the shipped container image sets `ACA_RUNNER_HOST=0.0.0.0` explicitly, so a deployed pool is unaffected — only a runner started by hand changes behaviour). An opt-in transport token, `ACA_RUNNER_AUTH_TOKEN`, makes `/execute` require a matching `X-Conductor-Runner-Token` header — checked before the inner Copilot provider is constructed — and `401` otherwise; the host sends the header automatically when the same value is set on its side. `GET /health` stays unauthenticated (the image's own `HEALTHCHECK` sends no header) but now reports `auth_required` and `auth_token_present`, letting the host warn when a gateway is silently stripping the header or when only one side has a token configured. The runner also rejects any `inner_provider_settings` key outside `base_url` / `api_key` / `bearer_token` / `github_token`, closing off `runtime_url` and `headers` injection, and `ACA_RUNNER_ALLOWED_BASE_URLS` optionally restricts which BYOK `base_url` values are accepted. See `docs/providers/aca.md#security`. ### Fixed - **A pathological gate or dialog prompt no longer stalls the event loop** (#395). `linkify_markdown` — which runs on human-gate prompts, dialog turns, and rendered agent prompts — degraded to quadratic time on inputs containing long unterminated runs of backticks/tildes or `[` characters, so agent-generated text could freeze every concurrent agent sharing the loop. The fenced-code opener no longer backtracks character-by-character, and existing-markdown-link detection is now a linear single-pass scanner (fuzz-verified equivalent to the regex it replaces). A defensive 256K character cap skips linkification entirely on anything larger — whitespace is still normalized — so a future pathological shape degrades gracefully rather than hanging. - **Token cost is no longer massively overstated for cached, tool-calling agents.** `AgentOutput.input_tokens` is the *whole* prompt and already contains `cache_read_tokens` / `cache_write_tokens`, but `calculate_cost` billed all four buckets additively — charging every cached token at the full input rate *and again* at the cache rate (11x on `claude-sonnet-5`). Because a long agentic loop re-reads almost its entire prompt from cache on every turn, the error compounded across turns: a real run reporting **$51.08** actually cost about **$8**. A cached bucket is now subtracted from the input bucket before the input rate is applied, so each physical token is priced exactly once — the same treatment `genai-prices` uses, including its rule that a bucket is only subtracted when a rate exists to charge it at (a `0.0` cache rate in the table means "no published rate", not "free"). Cost figures on the dashboard, the CLI summary, `agent_completed` events and the JSONL event log all drop accordingly; no workflow config changes. The Claude Agent SDK provider, whose Anthropic-shaped usage dict reports cached tokens *outside* `input_tokens`, now folds them in and reports both cache buckets, so cached tokens there are billed at the cache rate instead of not being billed at all — note this also makes that provider's reported `input_tokens` / `tokens_used` counts cache-inclusive, matching Copilot, so token totals rise even as cost falls. **If you set `limits.budget_usd`:** existing values were calibrated against the inflated figures and now permit correspondingly more real spend. Review them, particularly under `budget_mode: enforce`. - **`claude-opus-5` and the dotted Claude 4.5 names are no longer unpriced.** `DEFAULT_PRICING` had no `claude-opus-5` entry, and `get_pricing`'s versioned-suffix fallback only extends a key with a `-` delimiter — so the SDK-advertised `claude-haiku-4.5` never matched the dashed `claude-haiku-4-5` entry either. Those models fell back to `None` and were reported as unpriced whenever the provider's live pricing hook was unavailable (an older Copilot SDK, or a non-Copilot provider). Added `claude-opus-5`, `claude-opus-4.5`, `claude-sonnet-4.5` and `claude-haiku-4.5` at the published Anthropic rates. Both spellings are kept: the dashed keys are what price the date-suffixed Anthropic ids (`claude-haiku-4-5-20251001`). - **`gpt-5.6-sol`, `gpt-5.6-terra`, and `gpt-5.6-luna` are no longer unpriced** (#386). Added to `DEFAULT_PRICING` as exact keys at the existing GPT-5.x family rate ($2.00 in / $8.00 out per million tokens) — exact keys rather than a `gpt-5.6` prefix key so the three resolve silently instead of through `get_pricing`'s fuzzy-match warning path. `grok-4.5`, `gemini-3.6-flash`, `mai-code-1.1-flash`, and `mai-code-1-flash-picker` remain **deliberately** unpriced in the static table pending a published rate; an invented rate would print as a confident cost, which is worse than the honest `(N unpriced)` marker. The live provider-pricing hook prices any model whose SDK metadata carries `billing.token_prices` (verified for `claude-opus-5` in #418, on Copilot SDK `>=1.0.9` — already the hard floor pinned in `pyproject.toml`) — the static-table gap only matters when that hook is unavailable or the model's metadata lacks a rate. ### Added - **`conductor doctor --models` now shows per-model pricing** (#386). The Models detail table gained `Input $/Mtok`, `Output $/Mtok`, and `Pricing` columns — the last distinguishing `provider` (live `get_model_pricing` hook), `table` (static `DEFAULT_PRICING` fallback), and `none` (genuinely unpriced) so "why is my run unpriced" is answerable with one read-only command (pricing resolution adds no new network round-trip — the Copilot SDK memoizes `list_models()` for the process). `--json` gains matching `input_per_mtok` / `output_per_mtok` / `pricing_source` fields on each model object. ## [0.1.28](https://github.com/microsoft/conductor/compare/v0.1.27...v0.1.28) - 2026-08-12 ### Added - **Mid-run guidance for `--web` and `--web-bg` runs** (#400). The dashboard previously offered only Stop, Resume, and Kill — there was no way to correct a run's course without stopping it first. `conductor guide --text "..."` (auto-discovering the dashboard port) and a dashboard **Guide** button both POST to a new `POST /api/guidance` endpoint, which feeds a `GuidanceChannel` the engine drains at the next step boundary (agents, parallel groups, for-each groups, scripts, sets, and waits alike) or immediately if an agent is currently paused, in which case it resumes with the guidance applied — reusing a Copilot follow-up on the same session when one is available. The TTY Esc/Ctrl+G interrupt path now goes through the same `add_user_guidance` entry point, so that guidance is visible in the dashboard and JSONL log too, and parallel/for-each group members now receive the current guidance section (previously always omitted). `resume --guidance "..."` (repeatable) applies guidance to the restored context before the resumed agent runs. Protected by the same `CONDUCTOR_GATE_TOKEN` as `conductor gate respond` when configured. - **`conductor status` — see what is running without stopping it** (#384). `conductor stop` with no arguments lists background workflows, but stops one when exactly one is running, so the natural "what's running?" reflex was destructive precisely when there was a single run to lose. `status` never terminates anything and never removes a PID file, so a run stays discoverable even when its liveness cannot be confirmed. It prints each run's dashboard URL, which is otherwise unrecoverable once the launching terminal is gone, and `--json` makes it scriptable. A malformed PID file is skipped with a warning rather than taking down the listing. - **Git-backed plugin sources** (#380). `runtime.plugins` alone resolves against machine state — an installed plugin name, or a path — so a workflow shared with a teammate still needed "first install these plugins" in a README, and a teammate who skipped that step got a hard error rather than a working run. `runtime.plugin_sources` maps a marketplace name to where it comes from (`owner/repo#v1.4.0`, any http/https/ssh or `git@host:path` remote, or a local path), and `plugins:` entries reference it as `prs@acme`. The split follows the Copilot CLI's own settings, which separate `extraKnownMarketplaces` from `enabledPlugins` — eleven plugins commonly come from one repository, so inlining a URL per entry would either clone it eleven times or silently pick one of eleven refs. The load-bearing property is that `prs@acme` means the same thing whether the marketplace was declared, installed via a CLI, or is a local directory: a declared source registers its name into the same resolution table the installed roots populate, so git *feeds* resolution rather than adding a second code path. It also gives the ambiguity error added in #378 a second remedy — qualify `git` as `git@acme` instead of falling back to a path. Both repository shapes are handled: a `marketplace.json` catalog or a `plugin.json` single plugin, with a `plugin:` key for a repository that is both. There is **no lockfile** — the YAML is the lock. A ref that is a full 40-character SHA is pinned and fetched once; a tag, branch, or absent ref floats and is re-resolved every run, matching how workflow registries already behave. `conductor run` acquires sources up front and in parallel; `conductor plugin fetch` primes the cache as its own step, which is what keeps `conductor validate` off the network entirely; `conductor plugin list` reports what a run would load, including the component counts that make a change in what a plugin ships visible. An unreachable remote with a warm cache warns and reuses the checkout, so offline runs keep working. Checkouts are cached under `$CONDUCTOR_HOME/cache/plugins/`, keyed by resolved commit. Cloning shells out to `git`, so existing SSH keys and credential helpers apply and self-hosted forges work. Sources are resolved one at a time, so a source that is unfetched or broken costs its own diagnostic rather than the report for every healthy source beside it. The two are distinguished: an *unfetched* source is a warning naming `conductor plugin fetch`, since `conductor run` heals it, while a source that is itself wrong — a path that does not exist, a `path:` that escapes the checkout, an unparseable catalog — is an error, because no amount of fetching fixes it. A declared source that shadows a same-named installed marketplace is reported, since the two can ship different subagents or a different MCP server. See `examples/plugin-sources.yaml` and the Plugins section of `docs/workflow-syntax.md`. - **Output field constraints — `enum`, `pattern`, `minimum`/`maximum`, `minLength`/`maxLength`, `required`, `nullable`** ([#372](https://github.com/microsoft/conductor/pull/372)). An `output:` field could declare a type and nothing more, so "verdict is one of three values" or "score is 0-100" lived in the prompt, where it was a suggestion rather than a contract. The eight new keywords are emitted into the schema each provider shows its model and enforced when the response comes back, and because a violation raises the same `ValidationError` a type mismatch does, it lands inside the existing in-session recovery loop — the model gets a chance to correct itself before the workflow fails. Constraints are checked recursively, so they hold inside object properties and array items too. Illegal combinations are rejected at load time rather than at run time: `pattern` on a number, an `enum` whose members do not match the declared type, `minLength` above `maxLength`, a regex that does not compile. Unknown keys are rejected as well, so a misspelled `minlength` fails validation instead of quietly leaving the field unconstrained. `required: false` is allowed only inside object properties — a root-level output field cannot be optional. Two things worth knowing when using them. `pattern` runs under a one-second deadline on a `re`-compatible engine, because model output is untrusted input and a backtracking pattern would otherwise stall the event loop and every agent sharing it; an exceeded deadline is a validation failure, not a hang. And templates render with `StrictUndefined`, so a `nullable` field that came back null renders as `None` and an omitted optional property raises — guard both with `is not none` / `is defined`, as [`examples/output-constraints.yaml`](examples/output-constraints.yaml) shows. See [`docs/workflow-syntax.md`](docs/workflow-syntax.md) (Field Constraints). - **Plugins as the unit of opt-in** (#378). Conductor loaded a plugin's `skills/` and dropped everything else it shipped. That is a problem because a plugin's parts are written to work together: its `SKILL.md` routinely tells the agent to hand work to `prs:code-reviewer`, or to call an `ado` MCP tool. The skill loaded, the agent read those instructions, reached for a subagent that was never registered — and said nothing. `runtime.plugins` (and per-agent `plugins:`) now opts into the whole unit: skills, `agents/*.agent.md` subagents, and declared MCP servers. Entries take a string shorthand or an object with per-component switches (`skills`, `agents`, `mcp`), all defaulting on, because defaulting one off would recreate the partial load the feature exists to fix. An entry is an installed plugin name or a path, classified by the same syntactic rule `skills:` uses; an uninstalled name errors naming where it looked, and an ambiguous one errors rather than picking a winner. Conductor **deconstructs** a plugin rather than handing its root to the SDK: both SDKs' whole-plugin surfaces are all-or-nothing, and on Copilot hiding an MCP tool from the model does **not** stop its server subprocess launching with the user's credentials — so `mcp: false` built that way would be a guarantee that isn't one. Deconstructed, a plugin's MCP servers also pick up the same `runtime.tool_output` limits, dashboard tool events, and credential/`${VAR}` resolution as a workflow-declared server. Supported on `copilot` and `claude-agent-sdk`; `claude`, `hermes` and `aca` reject `plugins:` at validation time, since injecting text into a prompt cannot produce a subagent or an MCP server. `conductor validate` prints what each plugin contributes, including every subagent by name, so a change in what a plugin ships is visible before the run rather than during it. See `examples/plugins.yaml` and the Plugins section of `docs/workflow-syntax.md`. - **Copilot-convention plugin manifests are recognised** (#378). `.github/plugin/plugin.json` now resolves alongside `.claude-plugin/plugin.json`. Both have always worked at runtime, so recognising only the latter was Conductor's own gap — on an ordinary machine it stranded 12 of 13 installed plugins, which on `claude-agent-sdk` meant a packaged skill was rejected outright and on `copilot` meant it was silently demoted to a bare directory. - **`type: questions` — ask a human a set of questions in one step** (#376). `human_gate` handles a single decision; asking N questions previously meant hand-rolling a gate that loops back through a `set` step accumulating a string transcript. That loop cannot support going back — a workflow step cannot be un-executed, and a concatenated transcript has no addressable per-question answer to overwrite — and it costs two engine iterations per question. A `questions` node holds the cursor and answers internally, so the whole set costs one iteration and answers land in a keyed dict where revisiting question 3 overwrites `answers.q3`. Questions come from an inline `questions:` list or a `source:` dotted path; entries may be plain strings or objects with `choices`, so an agent already emitting `array of string` migrates unchanged while gaining candidate answers is a backward-compatible upgrade. Supports back/skip/skip-all/abort, `required`, per-question `default`s, a closing review, and partial answers that survive a checkpoint. `--skip-gates` never selects a suggested answer — those come from the agent, so recording one would feed invented input back as though a human gave it. See `examples/questions.yaml` and the Questions section of `docs/workflow-syntax.md`. - **Opt-in multi-line text for human gates** — `GateOption.multiline` (default `false`, so existing gates are unchanged). The terminal reads until a lone `.` or EOF; the dashboard renders a textarea where Enter inserts a newline and Ctrl/Cmd+Enter submits. Previously a multi-paragraph answer to a `prompt_for` input was silently truncated at the first newline. ### Removed - **`skill_discovery.sources: [plugins]`** (#378). The source scanned every installed plugin's `skills/` directory — reaching into a plugin and taking exactly one of the three things it ships, which is the bug `runtime.plugins` fixes rather than a feature with a gap. It was also wrong more often than it looked: of 13 plugins on an ordinary machine, 3 loaded their instructions without the subagents those instructions dispatch to, and the 3 most plugin-like — MCP and subagent toolkits with no `skills/` at all — were never discovered by it. Nothing distinguished the working set from the broken set at authoring time, on a machine the workflow author may not even be using. `personal` and `project` are unchanged. Replace `sources: [plugins]` with `runtime.plugins`, which brings the whole plugin and, unlike a scan, reproduces on another machine. ### Fixed - **`--web-bg` no longer reports success and prints a URL for workflows that never actually started** (#410). The launcher's readiness check used to trust a bare TCP connect: the moment *anything* accepted a connection on the dashboard port, it wrote the PID file, printed the URL, and exited 0 — even for a workflow that failed `load_config` moments later. Two changes close this: (1) `WebDashboard.start()` (which binds the port) now runs *after* `load_config` succeeds in `run_workflow_async`, so a `ConfigurationError` from a broken workflow never binds a port in the first place; (2) `_finalize_background_launch` now confirms the workflow actually started, not just that a socket answered. `_wait_for_server` checks the child's exit status on every iteration of its connect loop, so a dead child is detected in well under a second instead of after the full 15s timeout; a stage-two probe then polls `GET /api/info` (the same identity endpoint `conductor stop` already uses) for up to 30s (`CONDUCTOR_WEB_BG_START_TIMEOUT`, `0` disables it) until it reports a `workflow_started` event, exiting 1 with the exit code and a tail of the captured stderr log if the child dies first, or naming the conflicting PID if the port turns out to be held by an unrelated process. The PID file is written as soon as the port opens — before this second wait — so a slow-starting run stays visible to `conductor status`/`stop` throughout; if the child then dies, the entry is removed. Passing the 30s deadline with the child still alive is not treated as a failure — the URL is still printed, alongside a note that the workflow hasn't reported starting yet. - **Live provider pricing works again** (#386). Every Copilot model was being costed from the static `DEFAULT_PRICING` table instead of the live rates the SDK reports, and models absent from that table reported no cost at all. `CopilotProvider.get_model_pricing` reads `billing.token_prices`, and `github-copilot-sdk` 1.0.1 — the version the lock pinned — parsed the `models.list` response with a hand-written `client.ModelBilling` that declared only `multiplier` and discarded the `tokenPrices` wire field. The field never left the API and is still modelled in the SDK's generated types; only the client dataclass dropped it. The hook therefore returned `None` for every model, so the resolution chain #265 built (workflow override → provider hook → static table → unpriced) ran permanently on its fallback. No per-token rates were invented for the missing models; with the hook alive they price from the SDK. The field was restored in SDK 1.0.7; the floor moves to `>=1.0.9`, the version tested here. Moving the floor rather than only the lock is the point — the old `>=1.0.0` was satisfied by 1.0.1, so an existing environment kept dead pricing while reporting a healthy dependency. 1.0.9 also splits the cached-token rate into separate read and write prices and deprecates the single `cache_price` the hook read, which would have silently priced cache reads at $0.00, and it ships a pure-Python wheel that fetches the CLI binary on first use instead of bundling it per platform. `_default_permission_handler` no longer forwards `approve_all`'s result blindly. That helper stopped being unconditional: it abstains with `PermissionNoResult` when the runtime marks a request `managed_approval_required`, and raises when managed settings are enabled. Conductor is the only connected client, so an abstention is never answered — the CLI blocks on a pending permission request until idle recovery gives up minutes later and reports a timeout that blames the network. Both cases now decline explicitly and say why. Declining rather than approving is deliberate: managed approval is a policy control, and overriding it would turn a hang into a bypass. The existing hook tests built their models from `SimpleNamespace`, so they asserted what Conductor does with a billing object rather than whether the SDK still supplies one, and stayed green throughout. Tests now build the model through the SDK's own `ModelInfo.from_dict`, so the next SDK release that stops carrying the field fails the build instead of quietly reverting every run to static pricing, and the permission handler has behavioural coverage for the first time. - **Plugin checkouts from a `file://` source no longer land outside the plugin cache on Windows.** The cache key is derived from the URL's path segments, but the splitter only knew `/`, so a native Windows path arrived as a single segment with its backslashes intact — and the key kept them, putting the checkout at a drive-absolute location rather than under the cache root, which is the same escape the `..` check exists to prevent. Two further problems sat behind it: a drive colon made an owner of `C:_src` read as a drive (or, in the middle of a name, as an NTFS alternate data stream), and flattening a deep path into one segment produced a directory name long enough that `git` refused to create `.git` inside it. Separators are now folded, the characters that change a path's meaning on Windows are substituted, and an over-long segment is replaced by a digest of itself — on every platform, so one workflow file resolves to the same cache layout wherever it runs. - **Two sources resolving to the same commit no longer fail the whole fetch on Windows.** Publishing a completed checkout tolerates losing the race to a concurrent fetch, but recognised only the POSIX errnos for "destination already exists"; Windows reports that as `ERROR_ACCESS_DENIED`, so the tolerance never applied and the second source raised. Safe to accept because the readiness sentinel is written after publishing: a winner that died mid-clone leaves no sentinel, so the tree is re-fetched rather than read half-written. - **A local path is recognised the same way on every platform** — `_is_local_path` asked `pathlib.Path`, which is the *running* platform's flavour, so a POSIX absolute path such as `/srv/plugins` was refused as an unrecognised source on Windows. Both conventions are now consulted. - **Registry names are validated before they can corrupt the config** — a name containing a quote, a space, `=` or `#` was accepted, written into `registries.toml` as an unescaped table key, and then failed to parse. Since `registry add`, `remove` and `get` all load the config first, the user could not remove the entry that broke it and every unrelated registry went down with it. Names are now restricted to letters, digits, `.`, `_` and `-`, which also keeps them legal as cache directory names on Windows, and the table key is quoted so a dotted name stays one registry instead of becoming a nested table. - **`conductor doctor` no longer reports a missing Claude CLI on Windows** — the CLI probe dropped five `~`-anchored fallback locations on Windows, including `~/.claude/local/claude` where Claude Code's own installer puts it, so `validate_connection()` returned False for a CLI the SDK would find and run. Only `/usr/local/bin/claude` is now skipped there: it is rooted but driveless, so it resolves against the current drive, which any unprivileged local user can write to. - **Registry TOML values are escaped** — a registry whose source or type contained a quote or a backslash produced a file that could not be re-read. - **Dashboard context-window bar no longer reports cumulative input tokens as a false red at >100% of the cap** (#412). The bar reused `AgentOutput.input_tokens` — a *billing* total summed across every API call in an agent's execution — as a *context* measurement, so a multi-turn tool-calling agent (or a Copilot parse-recovery retry) could report more tokens than the model's context window physically allows. A new `AgentOutput.last_call_input_tokens` field carries only the prompt size of the most recent single API call, populated by every provider, and the engine now sources `context_window_used` from it instead. When a provider cannot isolate one call's prompt size, the field is `None` and the dashboard hides the bar rather than showing a misleading number; a `used > max` pair (impossible for one real API call) is dropped to `None` entirely, logged at debug on every occurrence and at warning once per run (nothing reads debug logs in production), since either the usage figure or the looked-up cap is untrustworthy. Riding along: `copilot.py`'s `assistant.usage` handler previously *overwrote* its running token counts on every event instead of summing them, so a 20-turn tool-calling agent's cost was billed only for its final API call — this under-report is fixed at the same time, since fixing it alone (without the new field) would have made the context bar report the sum of every turn rather than just the last, making the original defect worse. The event's dedup guard (which prevents a repeated `assistant.usage` event from double-billing the same API call) keys on `api_call_id`, falling back to `provider_call_id` then `service_request_id` when the SDK omits it, since all three are independently optional. Cost figures for multi-turn Copilot agents will rise as a result; a `cost.budget_usd` tuned against the old under-reported total may now trip its limit sooner. - **`conductor stop` no longer kills the run it is executing inside** (#399). An agent smoke-testing `conductor stop` from its own workflow's `bash` tool inherited that workflow's background environment and terminated itself — the process printed "Stopped" and was killed by what it printed. `stop` now identifies the run it is executing inside via `CONDUCTOR_RUN_ID` (set on every `--web-bg` child and inherited by descendants), the legacy `CONDUCTOR_WEB_BG`/`CONDUCTOR_WEB_PORT` pair (for PID files predating #411's `run_id` field), and POSIX process ancestry, and excludes it from targeting by default: `--all` now means "stop all *other* runs", the no-flag auto-stop skips it, and `--port ` is refused (exit `1`, naming `--allow-self` as the remedy). If only your own run is alive, `stop`/`stop --all` print a refusal and exit `0` rather than erroring, since nothing named was declined. Pass `--allow-self` to restore the previous targeting exactly; a yellow warning is printed whenever it actually causes your own run to be signalled. Process-ancestry detection is POSIX-only — Windows relies on the env-var signals alone. - **A pricing hook that silently prices nothing is now reported** (#386). #265 warns when the provider pricing hook *raises*; the companion case — a hook that never raises and returns `None` for everything — looked identical to "these models are simply unpriced", so live pricing could be dead for a whole run with no symptom beyond newer models showing up as unpriced. The verdict is drawn once when the run ends — however it ends, so a run that dies part way still reports it, which is when a partial cost total most needs the caveat — and is emitted as a `pricing_hook_silent` event as well as a log line, so it reaches the event log and the console rather than only unattributed stderr. The run summary gains `usage.live_pricing_degraded` and the cost breakdown prints a matching caveat, because a model priced from the static table still reports a confident cost and would otherwise carry no qualification. Providers that do not implement the hook are excluded: returning `None` is the documented default, so counting them accused four of the five providers of a broken SDK for behaving correctly. - **`conductor stop` now confirms the process actually stopped, and never stops the wrong one** (#344). `stop` sent one signal and reported success without checking, so a workflow that ignored it was reported as stopped and its PID file deleted — leaving a live run untracked, invisible to `stop`, and holding its port. Termination is now a ladder (ask the dashboard to cancel, then signal, then force-terminate), each rung confirmed before the next, and the PID file is removed only once the process is confirmed gone. Every PID-directed rung is gated on the dashboard confirming its own PID, because between a PID file being written and `stop` reading it the OS may have recycled that PID onto an unrelated process. `--force` overrides *uncertainty* only: a positive identity mismatch blocks every rung, force included. PID files are written atomically, so a concurrent `stop` can no longer read a half-written file and deregister a live run, and the reader logs before deleting anything it cannot parse. `--force` can clear an entry whose liveness cannot be probed, which would otherwise wedge `stop --all` at exit 2 permanently (#166). - **Bracketed text no longer crashes or corrupts CLI output** (#406). The same defect as #382, which #387 fixed only in `cli/run.py`. `conductor validate` died with an unhandled `MarkupError` traceback on a workflow whose `name:` contained `[/bold]`, and silently deleted the token when it contained `[dim]`. The quiet half is the more damaging one: a listing that drops part of a name looks like it worked. Rich treats a bracketed token as a style tag when its first character is lowercase, `#`, `/` or `@`, so `[0]` is fine, `[task1]` disappears, and `[/etc/x]` raises — and `style=` does not turn parsing off, which is what made the earlier fix look complete. Two consequences shipped unnoticed. Every for-each iteration's verbose panel read the same, because the engine qualifies a member's name as `[]` so interleaved output can be attributed to one iteration, and a `key_by:` key of `task1` erased exactly that identity — while a key starting with `/`, which `key_by:` over paths or URLs produces, killed the run from a logging call. This needed no flags: verbose and full mode both default on. Separately, `conductor status` (#389) and `conductor plugin list` (#398) were written against the unfixed pattern in files #387 never touched, and #398 made these strings third-party rather than the author's own YAML, since plugin, marketplace, skill and subagent names are now read out of git-cloned repositories. Rather than escape ~450 call sites, the default is inverted: every console is built by the new `conductor.console.make_console()` with `markup=False`, so a plain string is literal unless it asks to be styled, and conductor's own styling goes through `styled("