Skip to content

feat(runstore): operator call ceiling AGENTDESCENT_MAX_CALLS (Partial #1082) - #1181

Merged
Birfy merged 4 commits into
mainfrom
agent/1082-operator-run-cap
Nov 20, 2026
Merged

Birfy merged 4 commits into
mainfrom
agent/1082-operator-run-cap

Conversation

@HugoXK

@HugoXK HugoXK commented Nov 20, 2026 •

Copy link
Copy Markdown
Collaborator

Partial: #1082. This is one slice of the remainder, not its close.

Claimed under AGENTS.md "Claim, PR, release"; agent-ready is triage-side and applied to 0/18 open issues (repo-wide), so it was not waited on.

What changed

An operator per-run ceiling on model calls, AGENTDESCENT_MAX_CALLS, clamped into both run paths so a host worker cannot ask for an unbounded run and get it.

  • agentdescent/runstore.py: OPERATOR_MAX_CALLS_ENV and operator_max_calls(), which reads and validates it (a non-integer or negative value is a RunStoreError naming the variable); _clamped_max_calls() is a min: a caller's --max-calls lowers the ceiling, never raises it, and a run that passes no max_calls still gets the ceiling. Applied in launch and execute, so the CLI, a detached run and MCP start/resume all charge through it; the detached child is started with the clamped number as --max-calls, so it cannot be widened across the process boundary.
  • agentdescent/runstore.py, detached label: because the child's argv is already the clamped value, launch also passes what the caller asked for in AGENTDESCENT_MAX_CALLS_REQUESTED (an internal, label-only variable — a malformed or hand-set value can change nothing but the wording of stop_detail; enforcement stays the clamped argv, and a present-but-empty value means "the caller named no cap").
  • agentdescent/budget.py: CallLimit.source and BudgetStop(source=…). When the operator's ceiling is what bound the run, stop_detail reads max_calls (AGENTDESCENT_MAX_CALLS): N call(s) made, cap N instead of the bare max_calls — on the foreground and detached paths alike. A dollar stop never carries that source: a USD cap has no operator ceiling behind it (an un-priced one is refused before the run starts), so a run with both a ceiling and --max-usd names max_usd, not the call knob.
  • tests/test_operator_run_cap.py: eleven rows — the ceiling lowers a larger caller cap; it applies with no caller cap at all; a loose ceiling never loosens a caller's smaller cap (detail stays bare); a detached launch records --max-calls 2 when the caller asked 50; that child learns what the caller asked (AGENTDESCENT_MAX_CALLS_REQUESTED=50); the child's own view (requested 50, ceiling 2, argv 2) names the ceiling; equal caller/ceiling stays bare; a USD stop never names the call ceiling; a hand-set REQUESTED=50 does not blame a looser ceiling when the caller's own cap of 2 bound the run; the same from below (ceiling 2, caller 1); a detached run with no caller cap still names the ceiling.
  • docs/plugin-design.md: one bullet in the host-worker guards, next to the recursion guard, stating the foreground and detached behaviour.
  • changelog.d/1082-operator-run-cap.md (one Added entry).

Why Partial: and not Fixes:

  • Calls only, not dollars. A process-wide AGENTDESCENT_MAX_USD would turn every un-priced run into a SpecError, because require_budget_pair (runstore.py:90-98) refuses a USD cap with no usd_per_call. That is a contract decision, not a clamp; it stays open on #1082.
  • The other two rows are already shipped, verified here rather than quoted: write-dir confinement is #1087 (f5e9333) — _operator_write_guard at cli.py:3418, used at :3094 (materialised tree), :3800 (cmd_apply) and :3915; child-env scrubbing is #1088 (23979b7) — tests/test_host_env_scrub.py, 13 tests including one parametrised over SESSION_MARKERS itself.
  • Out of this slice: max_concurrency, the MCP tool arguments for the caps, and doctor reporting them.

Red first, at origin/main 14ba9529 with only tests/test_operator_run_cap.py — 3 failed, 1 passed

  • FAILED …::test_the_operator_ceiling_lowers_a_callers_larger_cap — the ceiling was ignored (assert 4 == 2 on the call count)
  • FAILED …::test_the_operator_ceiling_applies_with_no_caller_cap — the uncapped run made its full round's calls
  • FAILED …::test_a_detached_run_carries_the_operator_ceiling — the recorded child argv carried --max-calls 50
  • The green row at base is …::test_a_loose_operator_ceiling_never_loosens_the_callers_cap: a loose ceiling must change nothing, and it already did not.

Red first for the review fixes, at ac82e72 — 3 failed, 5 passed

  • FAILED …::test_a_dollar_stop_never_names_the_call_ceiling — max_usd (AGENTDESCENT_MAX_CALLS): $0.0000 spent, cap $0.0100
  • FAILED …::test_the_detached_child_learns_what_the_caller_asked — child env had no AGENTDESCENT_MAX_CALLS_REQUESTED
  • FAILED …::test_the_detached_run_names_the_ceiling_the_parent_applied — the child's detail was the bare max_calls
  • The green row is …::test_an_equal_cap_does_not_name_the_ceiling: an equal caller cap was already not attributed to the ceiling.

Red first for the label guard, at 0e84778c — 2 failed, 9 passed

  • FAILED …::test_a_hand_set_request_does_not_blame_a_looser_ceiling — max_calls (AGENTDESCENT_MAX_CALLS): 2 call(s) made, cap 2 on a run whose caller cap of 2 sat under a ceiling of 5: the label followed a stale inherited AGENTDESCENT_MAX_CALLS_REQUESTED=50 instead of the clamp, so operator_bound now also requires the applied value to be the ceiling. Enforcement unchanged — that row still stops at 2 calls.
  • FAILED …::test_a_hand_set_request_below_the_ceiling_stays_bare — same class from the other side (ceiling 2, caller 1, stale request 50): the detail said max_calls (AGENTDESCENT_MAX_CALLS): 1 call(s) made, cap 1.
  • …::test_a_detached_run_with_no_caller_cap_still_names_the_ceiling covers the one _requested_calls branch that had no row: launch records an empty AGENTDESCENT_MAX_CALLS_REQUESTED and the child still attributes the stop to the ceiling. Green at both tips — coverage, not a regression.

Verification at the tip

Tip SHA: 9cf109d

Ran:

  • pytest -q tests/test_operator_run_cap.py → 11 passed (the last three rows are the label-follows-the-clamp cases below)
  • pytest -q over the budget/runstore/surface set (test_budget_guard, test_call_budget, test_budget, test_budgeted_loop, test_budgeted_search, test_budget_round_warning, test_runstore_cli, test_runstore_tilde, test_cli_surface_error_envelope, test_cli_surface_p1, plus the new file) → 146 passed
  • pytest -q tests/test_mcp*.py → 137 passed; combined with the set above in one invocation → 283 passed
  • mkdocs build --strict → rc 0 (social plugin excluded on this host: it needs cairo and hangs; the config was otherwise untouched, and the temp config is not committed)
  • python -m tools.gen_api_docs --check → docs/api.md is up to date
  • python -m tools.changelog_fragments check → 86 changelog fragment(s) OK

Full-suite note: the suite at this branch's first tip ran as eight parallel chunks — 7884 passed, 21 failed, 10 errors, all docker/sandbox or environment rows, plus one timing test (test_async_evolve.py::test_shutdown_grace_is_respected_and_warns) that is flaky under load; the same node ids fail at pristine 14ba9529, and the one that differs passed on re-run. CI remains the line for the whole suite.

Not run:

  • docker rows — no docker daemon on this host
  • mkdocs build --strict with the social plugin (see above)

No UI surface: an environment variable and a stop detail only.

@HugoXK HugoXK added area:cli The agentdescent command line (cli.py, doctor, plan/evolve/status/apply) area:plugins Host plugins and installers: Claude Code, Codex, DSH, OpenCode, MCP server enhancement New feature or request labels Nov 20, 2026
@HugoXK

HugoXK commented Nov 20, 2026

Copy link
Copy Markdown
Collaborator Author

Verdict: CHANGES (advisory — .github/agent/review-policy.json lists only Birfy, so this account records no counting PASS)

Tip SHA: ac82e72fa18e58a7323da53f773dadab5445ea64 (read from the API in this turn; base 14ba9529, 1 commit, 5 files +157/−6, non-draft, head unchanged at post)

Ran (at this tip unless noted):

  • pytest tests/test_operator_run_cap.py → 4 passed
  • the body's budget/runstore set (test_budget_guard, test_call_budget, test_budget, test_budgeted_loop, test_budgeted_search, test_budget_round_warning, test_runstore_cli, test_runstore_tilde, test_cli_surface_error_envelope, test_cli_surface_p1, plus the new file) → 142 passed
  • pytest tests/test_mcp_plan_probe.py tests/test_mcp.py → 45 passed (a subset of the body's MCP number; I did not run the whole test_mcp* list)
  • pytest tests/test_host_env_scrub.py → 22 passed (the #1088 disclosure row)
  • red-first at base 14ba9529 with only the new test file: 3 failed, 1 passed — assert 50 == 2 (the ceiling was ignored), assert 52 == 2 (no caller cap), assert '50' == '2' (detached argv); the loose-ceiling row is the one that was green, as the body says
  • clamp: with AGENTDESCENT_MAX_CALLS=2, _clamped_max_calls(50) → (2, True), _clamped_max_calls(2) → (2, False), _clamped_max_calls(None) → (2, True)
  • gen_api_docs --check → up to date; changelog_fragments check → 86 OK
  • .github/scripts/risk_gate.py --pr 1181 → T2 (163 changed lines / 5 files)

Not run:

  • full pytest -q; mkdocs build --strict (no mkdocs in my venv); docker rows
  • CI: at my read build, otel-wire, risk tier (report only) and reviewed tip (report only) success, deploy skipped, test (3.9)–test (3.13) in progress. I did not wait for the test legs; this verdict rests on the local runs above.

Blocking:

  1. The max_usd stop detail can name AGENTDESCENT_MAX_CALLS. CallLimit.reserve passes self.source to both stops (agentdescent/budget.py:124-130), and BudgetStop.detail applies the name to the non-max_calls branch too (:76-82). Reachable whenever the operator's call ceiling binds (so source is set) and the dollar cap fires first. Measured end-to-end: env AGENTDESCENT_MAX_CALLS=2, execute(max_calls=50, max_usd=0.01, usd_per_call=0.02) → 0 calls, stop_reason="budget", stop_detail = max_usd (AGENTDESCENT_MAX_CALLS): $0.0000 spent, cap $0.0100. The run stopped on the dollar cap but names the call ceiling. Fix: pass the source only for the max_calls stop (or carry a per-limit source).

Non-blocking:

  1. A detached run's stop_detail is bare. launch clamps and passes --max-calls 2, but the child's _clamped_max_calls(2) with the env at 2 returns (2, False), so limit.source stays None (runstore.py:873-876, :891-894). Measured: foreground caller 50 → max_calls (AGENTDESCENT_MAX_CALLS): 2 call(s) made, cap 2; the child's inputs (caller 2, env 2) → max_calls: 2 call(s) made, cap 2. The cap itself is right in both; only the attribution differs, and the body, docs/plugin-design.md and the changelog say the detail names the variable for the detached path too. Either carry a marker across the detach boundary (the child cannot reconstruct "the caller asked 50") or scope those three sentences to the in-process path. The detached test asserts the argv only, so it does not pin the detail.

Everything else I checked matches the claim: the clamp is a min in both paths and a caller cannot raise it (runstore.py:719, :876); execute clamps inside the require_budget_pair try, so a bad env marks the run failed before anything starts; budget.py's shape is unchanged for callers that do not set the source (verified: max_usd: $… spent, cap $… without a name); the four rows are offline (counting_agent in-process, runstore.subprocess.run monkeypatched for the detached row); Partial: #1082 with no Fixes; #1087 f5e93335 and #1088 23979b73 are in history with the claimed subjects, _operator_write_guard is at cli.py:3418 and used at :3094/:3800/:3915, and require_budget_pair refuses an un-priced USD cap at runstore.py:90-98.

Risk / merge: risk_gate → T2; mergeable: true, mergeable_state: blocked; 0 reviews at this tip. Advisory only — the counting PASS and the click are the owner's.

@HugoXK

HugoXK commented Nov 20, 2026

Copy link
Copy Markdown
Collaborator Author

Verdict: PASS (advisory — .github/agent/review-policy.json counts only Birfy)
Tip SHA: 9cf109d9c5c15de69601af40b3ef18f3c8a75b9f (PR head matches, non-draft, base 14ba9529, 4 commits, 5 files +324/−5)

Ran (this host, clone at the tip, Python 3.10.12 / pytest 9.2.0, PYTHONPATH=., offline)

  • tests/test_operator_run_cap.py → 11 passed
  • the same file plus test_budget, test_budget_guard, test_budget_governor, test_call_budget, test_budgeted_loop, test_budget_round_warning, test_runstore_cli, test_runstore_tilde, test_host_env_scrub → 178 passed
  • red-first: tree at 0e84778c with only this tip's tests/test_operator_run_cap.py → 2 failed, 9 passed; both failures are the hand-set rows and both for the stated reason: max_calls (AGENTDESCENT_MAX_CALLS): 2 call(s) made, cap 2 (ceiling 5, caller 2) and … 1 call(s) made, cap 1 (ceiling 2, caller 1)
  • _clamped_max_calls matrix, measured directly: caller 50 / cap 2 → (2, True); caller 2 / cap 2 → (2, False); caller 1 / cap 2 → (1, False); no caller cap / cap 2 → (2, True); child (cap 2, REQUESTED=50, argv 2) → (2, True); equal caller/ceiling with REQUESTED=2 → (2, False); hand-set cap 5 + REQUESTED=50 + caller 2 → (2, False); cap 5 + REQUESTED=50 + caller 5 → (5, True); REQUESTED="" → (2, True); REQUESTED=abc/-5 ignored → bare; no ceiling → unchanged; AGENTDESCENT_MAX_CALLS=-1 → RunStoreError naming the variable
  • python -m tools.changelog_fragments check → 86 changelog fragment(s) OK; tools.gen_api_docs --check → docs/api.md is up to date; tools.gen_algorithms_docs --check → docs/algorithms.md is up to date
  • local risk_gate.py --pr 1181 → T3, 329 changed lines, 5 files

Not run

  • full suite; mkdocs build --strict (not installed in the review venv); docker rows (no daemon)
  • CI: the five test (3.x) runs were in_progress at read time — not waited for and not used as evidence here

Summary

  • The guard is where it must be: agentdescent/runstore.py:153-170, with bound now requiring present and max_calls == cap and (requested is None or requested > cap) (:169-171). The label follows the applied value, not the variable. The hole measured at 0e84778c (ceiling 5, caller 2, hand-set REQUESTED=50 → (2, True)) is (2, False) here and prints the bare max_calls, while enforcement still stops that run at 2 calls.
  • The detached path is plumbing, not wording: launch clamps at :757, the argv carries the clamped value at :775-777, and the requested number is written into child_env after scrub_host_env at :787-791. The child's own row (tests/test_operator_run_cap.py:132) names the ceiling, equal caller/ceiling stays bare (:142), and the REQUESTED="" branch names it (:184).
  • The USD stop carries no source (agentdescent/budget.py:124-131), so BudgetStop.detail() (:76-82) can prefix only max_calls; with the ceiling set, a dollar refusal reads max_usd: $0.0100 spent, cap $0.0100 (:92).
  • execute clamps inside the require_budget_pair try (runstore.py:916-921), so a bad ceiling value marks the run failed and re-raises instead of leaving a half-started run.
  • Every surface reaches those two functions: mcp.py:753 and cli.py:2736, :2747, :798.
  • The body is honest at this tip: Tip SHA: 9cf109d9…, Ran:, Not run:, No UI surface: …, Partial: #1082, no Fixes:.

Blocking

None.

Non-blocking

  1. tests/test_operator_run_cap.py:149-151 — three blank lines before test_a_hand_set_request_does_not_blame_a_looser_ceiling where the rest of the file uses two; there is no lint gate in this repo, so cosmetic.
  2. The ## What changed bullet still says the test file has “eight rows”; it has eleven (:49-197). The three new rows are described in the red-first section, but that bullet was not updated.
  3. Label edge, measured, not falsified: an inherited AGENTDESCENT_MAX_CALLS_REQUESTED can only add the ceiling name where the applied cap is the ceiling. In a nested detach a run whose own caller asked exactly the ceiling can inherit an ancestor's larger request and name the ceiling ((5, True) above); the detail is still true about the applied cap, so I record it rather than ask for a change.

Risk / merge

T3 (329 lines, 5 files, agentdescent/runstore.py) — advisory PASS only. Needs Danyang's PASS at 9cf109d9c5c15de69601af40b3ef18f3c8a75b9f and the merge click; a new commit voids this report.

…ing (#1082)

`_clamped_max_calls` returned `operator_bound=True` from the recorded request
alone, so a hand-set or inherited `AGENTDESCENT_MAX_CALLS_REQUESTED=50` under a
looser ceiling (5) with a caller cap of 2 printed
`max_calls (AGENTDESCENT_MAX_CALLS): 2 call(s) made, cap 2` -- blaming a ceiling
that never bound the run.

The label now requires the applied value to *be* the ceiling. The detached child
still names it, because its clamped argv is the ceiling; anywhere the applied
`--max-calls` sits below the ceiling the detail stays bare. Enforcement is
untouched: argv, the CallLimit value and the exit codes are the same.

Red at `0e84778c`: the new row printed the ceiling name. Green here: 9 passed.
…g branch (#1082)

Reviewer asked for the two branches the guard created:
- a hand-set `AGENTDESCENT_MAX_CALLS_REQUESTED` below the ceiling (ceiling 2,
  caller 1) must stay bare -- red at `0e84778c` with
  `max_calls (AGENTDESCENT_MAX_CALLS): 1 call(s) made, cap 1`;
- the detached run that names no caller cap: `launch` records the empty string
  and the child still attributes the stop to the ceiling, which is the one
  `_requested_calls` branch with no row.
@github-actions github-actions Bot added risk:T3 Risk tier T3 (core loop, release, process; needs Danyang's click), set by the controller agent-pr Pull request opened by an agent labels Nov 20, 2026
@Birfy

Birfy commented Nov 20, 2026

Copy link
Copy Markdown
Collaborator

Self-review (Birfy)

Tip SHA: 9cf109d
Ran:

  • .github/scripts/risk_gate.py --pr 1181 → T3 (path agentdescent/runstore.py; 329 lines / 5 files)
  • pytest -q tests/test_operator_run_cap.py tests/test_budget.py tests/test_budget_guard.py tests/test_call_budget.py tests/test_budgeted_loop.py tests/test_budget_governor.py tests/test_budget_round_warning.py → 102 passed
  • python -m tools.changelog_fragments check → 86 fragments OK on this branch (pre-v0.11.0 fold; the three-dot diff vs current main adds only changelog.d/1082-operator-run-cap.md)
  • Required CI at this tip → green (build, test 3.9–3.13, otel-wire)
    Not run:
  • Full offline suite locally — the CI test matrix is the line
  • A live detached child process — launch tests stub subprocess.run and check argv/env; execute tests cover the child's wording
    Findings:
  • No actionable defects. The clamp is a min on both launch and execute; a looser ceiling never raises a caller's cap; a USD stop does not name the call ceiling; AGENTDESCENT_MAX_CALLS_REQUESTED is label-only after the host-env scrub. Partial #963 remainder: write-dir confinement, per-Ticket budget caps, host MCP-config scrub #1082 as stated (no dollar ceiling, no doctor/MCP cap args).
    Verdict: PASS

@Birfy
Birfy merged commit a1b41e7 into main Nov 20, 2026
10 checks passed
@Birfy
Birfy deleted the agent/1082-operator-run-cap branch November 20, 2026 10:24
Birfy pushed a commit that referenced this pull request Nov 20, 2026
…`max_calls` / `max_usd` (#1186)

Fixes #1184.

Claimed under AGENTS.md "Claim, PR, release"; agent-ready is triage-side
and applied to 0/18 open issues (repo-wide), so it was not waited on.

## What changed

The run-level call cap (#1166) and the operator ceiling (#1082) were
both unreachable from the MCP surface: `plan` and `start` took
`budget_usd` / `usd_per_call` and nothing else, so a host that wanted
"at most N model calls for this run" had no lever except the
process-wide `AGENTDESCENT_MAX_CALLS`, which it cannot lower per call.

`plan` and `start` (both the tool bodies and the `maybe_tool` wrappers)
now take `max_calls` and `max_usd`. They validate through
`build_call_limit`, the same rule the CLI and the run store use, so a
bad value, or a `max_usd` with no `usd_per_call`, refuses **before a run
directory exists** and with the CLI's own sentence rather than a second
wording for this surface.

The operator's ceiling is applied with the same `min` as
`runstore.launch` / `execute`: a caller may lower it, never raise it,
and a caller that names no cap still gets it. The reply carries
`call_limit`:

- `{"max_calls": 3, "max_usd": null}` — nothing clamped it.
- `{"max_calls": 2, "max_usd": null, "source": "AGENTDESCENT_MAX_CALLS",
"max_calls_requested": 9}` — the ceiling bound a request of 9.
- `{"max_calls": 2, "max_usd": null, "source":
"AGENTDESCENT_MAX_CALLS"}` — the caller named no cap and the ceiling
applies anyway.

`source` and `max_calls_requested` appear only when the ceiling bound
the run, the same distinction `AGENTDESCENT_MAX_CALLS_REQUESTED` already
carries across the detach boundary: without them a host cannot tell "the
ceiling lowered your 9 to 2" from "you asked for 2". A request of
exactly the ceiling reports **not bound**, matching
`_clamped_max_calls`.

`start` passes the caller's own numbers to `runstore.launch`, not a
pre-clamped value: `launch` applies the same `min` and is what records
what was asked for in the child's environment, so handing it an
already-clamped number would make `requested == ceiling` and erase the
label from `stop_detail`, while the arithmetic stayed right. The
enforced clamp still crosses the process boundary as `--max-calls 2`,
which the test asserts on the child's argv. No argument means exactly
today's behaviour, and plain `plan` has no `call_limit` key.

`max_concurrency`, `doctor`, and any USD default for un-priced runs are
untouched, as the issue scopes them out: a process-wide dollar ceiling
would turn every un-priced run into a `SpecError` through
`require_budget_pair`.

## Red test on `f5017f93`

`tests/test_mcp_call_limit.py` alone at clean `f5017f93` → **8 failed, 2
passed**. The eight are the missing entry point, not a behaviour
disagreement:

- `test_plan_reports_the_cap_it_will_enforce` → `TypeError: Tools.plan()
got an unexpected keyword argument 'max_calls'`
- `test_start_caps_the_run_and_status_shows_it`,
`test_max_usd_alone_is_refused_with_the_cli_sentence`,
`test_a_caller_cap_above_the_operator_ceiling_is_clamped_and_labelled`,
`test_a_cap_equal_to_the_ceiling_is_not_reported_as_bound`,
`test_start_hands_the_clamped_cap_to_the_detached_child`,
`test_nested_start_is_unchanged` → the same `TypeError` on `start`
- `test_a_run_that_names_no_cap_still_gets_the_ceiling` → `KeyError:
'call_limit'`: the base payload has no such key, because only the new
path reports the ceiling it will enforce

The two that pass are the two "no cap, behaviour unchanged" rows
(`test_plan_without_a_cap_is_unchanged`,
`test_start_without_a_cap_is_unchanged`), which assert today's behaviour
and must hold before and after.

Provenance: re-measured at the base with only this branch's
`tests/test_mcp_call_limit.py` copied into a clean worktree of
`f5017f93` — `PYTHONPATH=$PWD pytest -o addopts=''
tests/test_mcp_call_limit.py -q` → `8 failed, 2 passed in 2.46s`; all
eight fail on the `TypeError` for the new `max_calls`/`max_usd` kwargs,
and the two passers are the rows named above. The behaviour rows are
asserted green **at this tip**: the run stops at the cap
(`stop_reason="budget"`, the ceiling named in `stop_detail`), the
child's argv carries `--max-calls 2` when the caller asked 9 under a
ceiling of 2, a refused `max_usd` leaves no run behind, and nested
`start` still returns its unchanged stub.

Clamp teeth, measured: with the `min` bypassed in the helper and nothing
else changed, the file went **2 failed, 8 passed**
(`test_a_caller_cap_above_the_operator_ceiling_is_clamped_and_labelled`,
`test_a_run_that_names_no_cap_still_gets_the_ceiling`). The probe was
reverted, not shipped; the file greps clean and is 10 passed.

Tip SHA: 4015bb8

Ran:
- `pytest -o addopts='' -q` (the full offline suite) at `4015bb8f` → 21
failed, 10 errors, 7924 passed, 51 skipped in 2169.68 s. The 31 red ids
are the **identical set** red on `14ba9529`, a commit that is five
commits **older than this PR's base** `f5017f93` — the five being
`38f9d90f` (release v0.11.0), `920dc8c3` (#1178), `98655111` (#1180),
`a1b41e76` (#1181) and `f5017f93` (#1177), i.e. four code merges sit
between the baseline and the base. That is the stronger direction: the
same ids are red *before* those merges as well, so neither this branch
nor the four merges in between accounts for them; the red ids are docker
engine, exec-bit and wheel-smoke environment rows, and the comparison is
a same-id `comm` (empty both ways), not a count. No red id touches
`mcp`, `plan`, the run store caps or this new file. The one count
difference from the earlier `c6000830` measurement is
`test_dsh_superagent_run.py::[tmux]`, which is load-flaky (it passes in
isolation at both commits) and passed in this run.
  - `pytest tests/test_mcp_call_limit.py` → 10 passed
- focused set (`test_mcp_call_limit`, `test_mcp`, `test_mcp_meta`,
`test_mcp_plan_probe`, `test_mcp_http_transport`,
`test_operator_run_cap`, `test_budget_guard`) → 116 passed
- `python -m tools.changelog_fragments check` → `5 changelog fragment(s)
OK`
  - `python -m tools.gen_api_docs --check` → `docs/api.md is up to date`
- `python -m tools.gen_algorithms_docs --check` → `docs/algorithms.md is
up to date`
- `mkdocs build --strict` → rc 0, 12.4 s, with the `social` og-image
plugin stripped in a temporary untracked `mkdocs-local.yml` (it blocks
on a font fetch in this sandbox; CI runs the full config)
Not run:
- real-model probe / USD cap against a live provider → `ARK_API_KEY` is
not in this box's environment; every test row is offline and the cap is
arithmetic, not a model call
  - wheel smoke → no packaging or release path change
  - `doctor`, `max_concurrency` → explicitly out of scope in the issue

No UI surface: this adds two tool arguments, one JSON block and a docs
row; there is no UI to screenshot.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

agent-pr Pull request opened by an agent area:cli The agentdescent command line (cli.py, doctor, plan/evolve/status/apply) area:plugins Host plugins and installers: Claude Code, Codex, DSH, OpenCode, MCP server enhancement New feature or request risk:T3 Risk tier T3 (core loop, release, process; needs Danyang's click), set by the controller

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants