Skip to content

fix(cron): run command crons on hosts whose /bin/sh is bash - #7414

Closed
SebastianYuSun wants to merge 1 commit into
kirodotdev:mainfrom
SebastianYuSun:fix/cron-command-shell-brace-off
Closed

SebastianYuSun wants to merge 1 commit into
kirodotdev:mainfrom
SebastianYuSun:fix/cron-command-shell-brace-off

Conversation

@SebastianYuSun

@SebastianYuSun SebastianYuSun commented Sep 1, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Every command cron is refused on a Linux host whose /bin/sh is bash — the
default on AL2023, RHEL and Fedora — with ❌ No POSIX shell available to run this command cron. After five consecutive failures the job pauses itself.

There is no host-side workaround. _resolve_command_shell() in
src/kiro_crew/cron_script.py consults only /bin/sh and /usr/bin/sh, so
installing dash somewhere else does not help.

Why it matters

The command cron surface does not work at all on the most common Linux
configuration. The user sees the worst shape of failure: the job is accepted
when they create it, fails at every tick, then disables itself. A scheduled job
simply stops happening.

What changed (motivation → approach → change)

Symptom. _resolve_command_shell() returns None even though /bin/sh
exists and is trusted.

Root cause. _shell_is_posix_strict() probes one form, sh -c, and accepts
a shell only if it keeps x.{a,a} literal. bash expands that word, so both
trusted candidates fail. The probe defends something real: the gate reads a
command once at storage time, so a shell that composes words at run time widens
what the gate can be blind to, and brace expansion is a form it never refused.

Change. src/kiro_crew/mcp_cron.py refuses bash brace-expansion syntax in
_vet_shell_command, beside the composition forms already refused there, with the
same script-job remedy. It reads quote state instead of matching a pattern,
because bash needs the braces and the separator unquoted but not the alternatives.
It scans two levels: the command as written, and as a nested shell receives it
after quote removal. src/kiro_crew/cron_script.py then accepts a shell with
expansion off (+B). The plain form is probed first, so dash and ash resolve as
before with byte-identical argv, and one shared argv builder serves probe and
executor so the form that passed is the form that runs. The scan also runs at
fire time for command jobs, which is what reaches jobs stored before the
refusal existed: the run fails, the job is kept, and the refusal is audited under
cron_command_body. A backslash-newline is folded once ahead of every scan,
since the shell deletes it before parsing and it otherwise splits any token a
static rule matches on.

A command longer than 8192 characters is refused before any of that runs.
Every rule above is at least O(n) in space -- the fold builds a new string and the
quote scan builds two lists at a measured 16 bytes per character -- so on the import
path, which vets the raw dict value with no field-length cap, the memory is committed
before anything could raise. An OOM there is a SIGKILL that the caller's
except Exception cannot turn into a dropped job. The ceiling sits just above the
5000 a command can be stored at, rather than far above it, because a single long word
is quadratic through these rules independently of the brace walk's step budget
(measured 781 ms at 8k, 11.4 s at 32k, 178 s at 128k); at 64 KiB the same path would
cost about 45 s per call. That cost is present on the base commit at the same
measurements, so it is not introduced here, and it is reported through the private
channel rather than described further in a public comment.

stored cron command before after
echo hi, host /bin/sh → bash 🟥 refused, no shell found 🟩 runs
echo hi, host /bin/sh → dash 🟦 runs 🟦 runs, argv unchanged
a brace group hiding a path 🟥 stored, then run 🟩 refused at storage and each fire
awk '{print x, y}', find . -exec {} ; 🟦 allowed 🟦 allowed
a quoted interval, grep -E '[0-9]{1,3}' 🟦 allowed 🟨 refused, remedy in the message
a command over 8192 chars (import path only) 🟥 scanned, allocating per character 🟩 refused before allocating
an unquoted escaped brace, echo \{a,b\} 🟦 allowed 🟨 refused
awk '{print}' f | grep ',}' 🟦 allowed 🟨 refused
docker ps --format '{{.ID}},{{.Names}}' 🟦 allowed 🟦 allowed
a backslash-newline split of any vet trigger 🟥 slips past the rule 🟩 folded first, then refused

🟩 added · 🟨 changed · 🟥 removed · 🟦 unchanged

Command crons start working on the most common Linux host, and the words a shell
can build at run time stop reaching the executor unseen.

What this costs

The fire-time scan applies the refusal to jobs that already exist. A stored
grep -E '[0-9]{1,3}' cron that ran fine under dash fails on every fire until
someone edits it. The failure is audited and the message carries the remedy
(grep "[0-9]\{1,3\}" for a BRE tool), but it is permanent until that edit. Two
more shapes are refused on the same terms: an unquoted escaped brace
(echo \{a,b\}), and a quoted brace group whose separator arrives in a later
argument (awk '{print}' f | grep ',}'). All three are behaviour changes on hosts
that were working, and belong in the release notes of the version shipping them.

Extglob is a second composition form +B does not switch off, building paths no
static scan sees. Any host with bash already reaches it, since a cron command can
invoke bash explicitly whatever /bin/sh is. Refusing @( +( !( ?( *(
quote-blind would also take awk '!(NR%2)', so the precise fix teaches
_glob_could_reach_credentials about extglob, in its own review.

Windows still refuses command crons, unchanged.
docs/guides/windows-install.md drops brace expansion as the stated reason and
gives the real one: a shell whose language is wider than the vet's.
docs/system-specs/modules/governance.md gains the third fire-time check, and
docs/system-specs/modules/learn-cron-dashboard.md records that a command body
is re-scanned on a script body's terms.

Tests

test/test_mcp_cron_security.py adds the brace-expansion payloads to
MALICIOUS_COMMANDS, each hiding a path whose literal text the credential scan
cannot see: the comma form, the sequence form, the nested form, the set -B
re-enable route, four quoted and escaped-whitespace spellings, the nested-shell
form, and three unquoted-escape spellings. Brace-bearing commands that no shell
expands sit beside them, so the refusal cannot widen into find -exec {} ; or
awk '{print x, y}'.

Two ways of moving the separator out of the opening brace's quote state are
covered, because they are siblings and only the first is visible to a
single-level rule. Quote concatenation puts the separator between two quoted
runs. An unquoted backslash escapes it instead, and since a backslash outside
quotes is the shell's own escape character, quote removal deletes it and a nested
shell receives the separator bare — measured with neutral tokens,
/bin/sh +B -c '/bin/sh -c "echo "p{x\,x}q' prints pxq pxq, the same as the
unescaped control. _strip_shell_quotes therefore drops an unquoted backslash
while keeping one inside quotes, where it survives into the inner shell and the
word stays literal. One spelling of this carries no quote character at all
(sh -c cat\ …), so a rule conditioned on quotes being present would still miss
it.

A third way hides the group's boundary instead of its separator, and it is the
cheapest: a bare } at depth 0, with no quoting, no escape and no nesting. bash
does not close a separator-free group there — it keeps hunting for a later }
that does have a depth-0 separator before it — so echo p{x},x}q prints
px}q pxq. The scan follows bash and treats such a } as ordinary text.

The three together are checked by exhaustive measurement rather than by example.
Every word up to six characters over two alphabets — { } , x \ space " ' for the
quoting shapes and { } . , x \ space for the .. sequence form — is run under
bash -c and bash +B -c and compared with the scan's verdict. That is 31,386
and 44,814 bash-accepted words. Zero of them expand while the scan allows them.
(A $ is deliberately absent from both alphabets: $$ is the shell's PID, which
differs between the two processes being compared and reads as an expansion that is
not one.)

_BRACE_SHAPES_MEASURED_AGAINST_BASH carries the decision table, every row run
rather than reasoned: the same word is echoed under bash -c and bash +B -c
and the outputs compared, and the nested level is measured through
bash -c 'bash -c "..."'. The assertion is one-directional by design — a shape
some shell expands must be refused, while refusing a shape every shell leaves
literal is only a false positive. A third column pins the exact over-refusals, so
a later change cannot trade one for a hole.
test_brace_scan_keeps_a_nested_shell_covered pins the nested-shell coupling,
including the quote-concatenation spelling.

test/test_cron_script_more_coverage.py pins the probe order (plain form first,
then +B), that a strict shell keeps its exact argv, that the real spawn carries
the form the probe proved, and that a shell which expands in every form records
no form for a later caller.

Measured on this branch: 477 passed, 1 skipped across
test_mcp_cron_security.py, test_cron_script.py and
test_cron_script_more_coverage.py.

test/test_mcp_cron_security.py becomes black-clean, so its line in
.github/black-baseline.txt is pruned and the baseline keeps shrinking.

Manual verification

Run on a host whose /bin/sh resolves to /usr/bin/bash, which is the affected
configuration:

readlink -f /bin/sh            -> /usr/bin/bash
/bin/sh -c 'echo x.{a,a}'      -> x.a x.a       (plain form fails the probe)
/bin/sh +B -c 'echo x.{a,a}'   -> x.{a,a}       (the form the probe accepts)

Against the same host, 14 command shapes that main allows are refused on this
branch, and 4 brace-bearing commands that no shell expands stay allowed. The
shell measurements are unstubbed subprocess runs. The probe measurements stub
wrap_argv to the identity, because this host has no user-namespace sandbox
backend and would otherwise fail closed for a reason unrelated to the behaviour
under test.

Screenshots / video

N/A — no user-visible UI change. The diff touches the cron command shell
resolver, one storage-time vet predicate, their tests and three specs. No panel,
component, layout or theme is involved.

Related Issues

Fixes #7412

Pattern harvest

Rule candidate: review-prompt
Pattern: a probe and the executor it certifies build their argv from two separate
literals, so the probe keeps passing while the executed form diverges. Any
"prove this invocation is safe, then run it" pair should share one builder.

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title (feat|fix|docs|refactor|perf|test|chore|ci|build|revert: ...)
  • Existing tests pass and new tests added for new functionality
  • Self-review completed; code follows project style guidelines
  • Documentation updated (if applicable)
  • No secrets, credentials, or internal references in the diff

@SebastianYuSun
SebastianYuSun requested review from a team and CrysisDeu September 1, 2026 01:08
@github-actions github-actions Bot added readiness: checking Automated validation is still running fork Pull request from a fork (external contributor) labels Sep 1, 2026
@SebastianYuSun
SebastianYuSun force-pushed the fix/cron-command-shell-brace-off branch from 16f3684 to d94950d Compare September 1, 2026 01:16
@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running and removed readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention labels Sep 1, 2026
@SebastianYuSun

Copy link
Copy Markdown
Contributor Author

Coverage Gate is red because of one cancelled shard, and the cancellation is a
job timeout rather than a test failure. Posting the measurements so a re-run of
that single job is all that is needed.

Coverage Gate is an aggregator — its log says exactly this and nothing else:

coverage-combine=skipped  frontend-test=success  frontend-coverage-merge=skipped
backend-test=cancelled  only_backend=true  only_frontend=false
::error::backend-test=cancelled -- failing closed.

backend-test is timeout-minutes: 30 with fail-fast: false, so a lone
cancelled shard whose siblings all passed can only be the 30-minute wall.

On this head, Backend Tests (3.12, 1) was cancelled at 30.25 min while its
three siblings passed at 27.87 / 27.33 / 28.32 min. The lane is not near the cap
because of this PR — measured on main with no PR diff at all, run 33456335135
took 28.35 min on (3.12, 3) and 27.37 min on (3.12, 2). That is about
1.6 minutes of headroom on a 30-minute limit, so whichever shard draws a slower
runner crosses it.

The same boundary was crossed an hour earlier on an unrelated PR, on a different
shard: (3.12, 2) cancelled at 30.27 min there.

This diff cannot account for it. It adds 7 tests across
test_cron_script_more_coverage.py and test_mcp_cron_security.py; those two
files plus test_cron_script.py run in 6.5 s in total locally. The one
behaviour change that touches a subprocess — the shell probe now tries a second
invocation form — does not fire on the runners: /bin/sh is dash on
ubuntu-latest, so the plain form passes first and exactly one probe process is
spawned, as before. The second form is reachable only on a host whose /bin/sh
is bash.

The branch is up to date with base (behind 0), so a rebase would change no
result and would only reset the fork workflow approval. I have deliberately not
touched the diff or force-pushed.

Could a maintainer re-run the cancelled Backend Tests (3.12, 1) job? Happy to
open a separate issue about the shard-timeout headroom itself — the matrix comment
already notes that adding a group means extending the list and bumping
SHARD_COUNT, which looks like the intended remedy.

@bolichen97

Copy link
Copy Markdown
Contributor

Audit note — #7608 is being closed in favour of this PR

You are the surviving implementation; #7608 is being closed.

What the two shared

Both PRs add the same predicate to the same function at the same insertion point: a module-level bash-brace regex declared right after _CRON_BRACE_EXPANSION_RE (origin/main:mcp_cron.py:152) plus an if <re>.search(command): return "Error: cron command blocked: ... brace expansion ..." branch dropped into _vet_shell_command in the gap between the ${ branch (ends origin/main:620) and _CRON_POSITIONAL_PARAM_RE (origin/main:621), with the identical 'ship a script job' remedy. I imported kiro_crew.mcp_cron and confirmed origin/main returns None for every brace payload, so both are adding the same missing refusal from the same starting state; only one of the two branches can exist there. That is 100% of #7608 (one file, +27/-13, no test file at all -- its body's Tests bullets are unpinned) and it is half 1 of #7414, whose other half (cron_script.py +91/-25: the two-form +B probe, _probe_one_form, the shared _command_argv, _BRACE_OFF_SHELLS) plus 116 lines of tests is what actually fixes issue #7412 and has no counterpart in #7608. #7608's only non-duplicated content is black reformatting of untouched lines in a file baselined at .github/black-baseline.txt:304 that it does not prune -- churn, not wanted work. the first adjudication's rationale is however wrong on one point I disproved: #7414's regex is NOT strictly broader. Running both against the real _vet_shell_command, #7414 blocks the alphabetic-range class (cat ~/.s{s..s}h/id_rsa) that #7608 allows, and #7608 blocks the nested-comma class (cp ~/.a{w,{w}}s/credentials, real bash -> .aws .a{w}s) that #7414 allows, because #7414 excludes { from its inner character class. Neither is a superset, so the redundancy survives but the survivor must not merge as-is: #7414 is the very change that makes a brace-expanding bash the cron executor, so the class it misses goes from inert on main to live under it.

What #7608 had that this PR does not

Please pick these up (or say they are not wanted) so they do not disappear with that branch:

src/kiro_crew/mcp_cron.py -- #7608's character class. Before closing #7608, widen #7414's _CRON_BASH_BRACE_EXPAND_RE from \{[^{}\s]*(?:,|\.\.)[^{}\s]*\} to \{[^}\s]*(?:,|\.\.)[^}\s]*\} (drop { from both inner classes, keeping #7414's (?:,|\.\.) alternation) so it refuses the nested-comma form as well as the alphabetic range. Verified: the widened pattern blocks cp ~/.a{w,{w}}s/credentials /tmp/x, set -B; cat ~/.ss{h,{h}x}/id_rsa, cat ~/.s{s..s}h/id_rsa and cat ~/.a{w,w}s/credentials while still allowing find /tmp -name '*.log' -exec rm {} ;, echo {print}, awk '{print x, y}', awk '{print $1,$2}' and echo {a b,c}. Also add the two nested payloads to MALICIOUS_COMMANDS in test/test_mcp_cron_security.py, since #7414's existing four payloads do not cover that shape. This is a merge blocker for #7414, not optional: #7414's cron_script._shell_is_posix_strict two-form probe is what makes a brace-expanding bash the cron executor, so the class its regex misses becomes reachable exactly under the form #7414 adds. Nothing else in #7608 needs carrying: its error string is a weaker paraphrase of #7414's, it adds no test, and its remaining lines are black churn on baselined, untouched code.

This PR still needs work: CONTINUE_DEV

Neither side has merged, so nothing is superseded. git grep BASH_BRACE origin/main is empty and origin/main's mcp_cron.py still carries only the ${-form _CRON_BRACE_EXPANSION_RE; importing the module confirms all five brace payloads return None today. The one change origin/main made to _vet_shell_command since the earlier rounds is the enabled_rule_ids threading around line 658, well below both PRs' insertion gap at 613-621, so neither insertion point moved and no landed cron commit in the landed-commit index for main touches brace vetting. #7412 is an open ISSUE (the issue/PR reference check), i.e. the shared motivation, not a covering change.


From a repository-wide duplicate/overlap audit of every pull request open against main (2026-09-02, 330 PRs, one reviewer per PR). Each PR was read as its full merge-base diff plus its description and every comment and review, then compared against each candidate PR's own diff and against origin/main at 1a765b88ceb7. This PR is not being closed — the note is informational. If the reading is wrong, please correct the reasoning rather than just the conclusion.

@SebastianYuSun
SebastianYuSun force-pushed the fix/cron-command-shell-brace-off branch from d94950d to e4506d4 Compare September 2, 2026 20:28
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Sep 2, 2026
@SebastianYuSun

Copy link
Copy Markdown
Contributor Author

Rebased onto a030091b4; head is now e4506d47. Two things changed since the last review.

The Coverage Gate red is gone at the source. It was never this diff -- backend-test was capped at 30 minutes while the coverage-bearing 3.12 shards ran 27 to 30, so whichever shard drew a slower runner was cancelled and Coverage Gate failed closed on the missing artifact. 7827b0392 raised that cap to 40 with a comment describing the same failure mode, and #7780 collapsed the matrix to 3.12. Both are on main, so this rebase picks them up.

A nested-brace bypass in this PR's own regex is now closed. The inner character classes were [^{}\s]*, which excluded { -- so an outer brace pair containing an inner { read straight past the screen while bash still expands it:

$ echo .a{w,{w}}s
.aws .a{w}s
$ echo .ss{h,{h}x}
.ssh .ss{h}x

The first word of each expansion is the credential directory, so cp ~/.a{w,{w}}s/credentials /tmp/x would have passed the gate. The classes are now [^}\s]*, which keeps the whitespace-free requirement that lets find -exec {} ; and awk '{print x, y}' through while refusing the nested comma form. Two cases were added to MALICIOUS_COMMANDS to pin it.

This matters specifically because of the other half of this PR: the +B probe is what admits a brace-expanding bash as the cron executor in the first place, so the storage-time screen has to be airtight for shapes that only that executor would expand.

Local gates on the pushed head: black gate (repo wrapper, 4 files in scope), isort, flake8, mypy over src/kiro_crew/ all clean; scrub-lint stage 1 clean; 356 passed / 1 skipped across the three affected test files.

@SebastianYuSun

Copy link
Copy Markdown
Contributor Author

Backend Tests (Windows) (2) is red on e4506d47, and it is not this diff. Recording the attribution so the red is not left unexplained.

The failure is a wall-clock ratio assertion, not a behaviour failure:

test/test_denied_commands_security.py::TestNestedPayloadExtractionIsLinear::test_the_scan_is_linear_not_quadratic
E   AssertionError: 0.0438s -> 0.1351s looks super-linear
E   assert 0.13510329999996884 < (0.04379360000007182 * 3)

Ratio 3.08 against a bound of 3.0, i.e. it missed by 2.7 percent of the threshold on a shared Windows runner. Shards 1, 3 and 4 all passed.

It exercises security._nested_shell_payloads, which walks a token list. This commit touches four files -- cron_script.py, mcp_cron.py, test_cron_script_more_coverage.py, test_mcp_cron_security.py -- and none of them is security.py. I checked the one plausible way it could have been mine: the amend in this PR widened _CRON_BASH_BRACE_EXPAND_RE's inner classes from [^{}\s]* to [^}\s]*, and a widened class can cause backtracking, so a test named "the scan is linear not quadratic" was worth ruling out rather than assuming. It is a different code path -- that regex is in mcp_cron._vet_shell_command and is never reached from _nested_shell_payloads, which does no regex matching at all.

The linearity property itself came from #7122, later touched by #7013 and #7356, none of them mine.

I have not claimed a measured flake rate, because a Windows runner's wall clock is not reproducible here -- this is "not reproduced, platform mismatch" with the ownership paths above excluded, rather than a flake verdict. A re-run of that one shard is the cheapest way to settle it.

@SebastianYuSun

Copy link
Copy Markdown
Contributor Author

Blocker closed, and thank you for finding it — the nested-comma class was a real hole in this PR's regex, and your framing of why it matters here is exactly right: this PR is what makes a brace-expanding bash the cron executor, so a class that is inert on main goes live under it. It is now fixed on head e4506d47.

Your prescribed change, applied verbatim. The pattern is now the widened form, character for character:

pattern: \{[^}\s]*(?:,|\.\.)[^}\s]*\}
matches the required widened form: True

Both inner classes dropped {, the (?:,|\.\.) alternation is kept.

Your verified table, re-measured against the real _vet_shell_command on this head. brace_re is whether _CRON_BASH_BRACE_EXPAND_RE itself matched:

=== must block ===
  BLOCK  brace_re=True   cp ~/.a{w,{w}}s/credentials /tmp/x
  BLOCK  brace_re=True   set -B; cat ~/.ss{h,{h}x}/id_rsa
  BLOCK  brace_re=True   cat ~/.s{s..s}h/id_rsa
  BLOCK  brace_re=True   cat ~/.a{w,w}s/credentials

=== must allow ===
  ALLOW  brace_re=False  find /tmp -name '*.log' -exec rm {} ;
  ALLOW  brace_re=False  echo {print}
  ALLOW  brace_re=False  awk '{print x, y}' /tmp/f
  BLOCK  brace_re=False  awk '{print $1,$2}' /tmp/f
  ALLOW  brace_re=False  echo {a b,c}

One correction to the note, in your favour rather than against it. awk '{print $1,$2}' is not allowed by the gate — it is refused, but by _CRON_POSITIONAL_PARAM_RE, not by the brace rule. That refusal is pre-existing on main: the pattern there is r"\$[0-9@*#]|\$\{[0-9@*#]" and it matches the $1. So the property you were actually testing holds — the widening introduces no new false positive, brace_re=False on that command — but the command itself was already unavailable on this surface before either PR. Worth stating precisely so nobody later reads it as a regression this PR caused.

Tests. Both nested payloads are in MALICIOUS_COMMANDS (test/test_mcp_cron_security.py:208-209) with a comment recording the measured bash expansion (echo .a{w,{w}}s -> .aws .a{w}s, i.e. the first word IS the credential directory) and why the shape is reachable only under the +B executor this PR adds.

Nothing else from #7608 picked up, agreed on your reasoning: the weaker error string, and black churn on lines baselined at .github/black-baseline.txt:304.

Also confirmed on your CONTINUE_DEV point: git grep BASH_BRACE origin/main is still empty and main's _vet_shell_command still returns None for every brace payload, so nothing here is superseded. This head is additionally rebased onto a030091b4, which picks up 7827b0392 (backend-test 30 -> 40 min) and #7780 (matrix collapsed to 3.12) — that is what cleared the Coverage Gate red this PR was carrying, and it was never this diff.

@SebastianYuSun

Copy link
Copy Markdown
Contributor Author

Correcting my earlier triage of this red with measurements, because the honest verdict is weaker than what I wrote before.

What I claimed last time: that a Windows runner's wall clock is not reproducible here. That was an assumption, not a measurement -- the test is pure Python timing and runs on Linux fine. So I measured it.

Measured, 20 runs under CPU contention on Linux: STABLE 0/20. That is not a flake verdict. It is absence of evidence, so I am not claiming this is a flake.

Ownership, which is what I can settle. The failing assertion is
test/test_denied_commands_security.py:4496, exercising security._nested_shell_payloads. This PR's commit touches four files -- cron_script.py, mcp_cron.py, test_cron_script_more_coverage.py, test_mcp_cron_security.py -- none of them security.py or that test file. git log -S on both the assertion text and the code under test names #7122, #7149, #7013, #7356 and #7335; none is mine, so this is not the "my own already-merged work" case either.

staleness on both implicated paths returns REBASE_WONT_HELP (20 behind, upstream touched neither), so I am deliberately not rebasing again -- on a fork PR that would reset the workflow-approval gate and change nothing about this failure.

The part that may actually be worth your attention. 283625e16 -- "test: assert linearity structurally, not by wall-clock ratio (#7321) (#7335)" -- is already on main, so the repo has decided this assertion shape is wrong. Two wall-clock ratio assertions survived that cleanup:

test/test_denied_commands_security.py:4496   assert large < small * 3, ... "looks super-linear"
test/test_denied_commands_security.py:4517   assert large < small * 3, ... "looks super-linear"

Line 4496 is the one that failed, at ratio 3.08 against a bound of 3.0 -- 2.7% over, while shards 1, 3 and 4 passed. The test's docstring says the 3x bound is "generous ... so scheduler noise on a shared runner cannot red it"; on this runner it did. Widening the bound does not fix the shape, because it has to stay below the quadratic 4x signal while clearing worst-case noise, and those are not cleanly separated on a shared Windows runner. The assertion on the next line (assert large < 1.0) is the one that actually pins the ~13 s quadratic regression the class was written for, and it passed.

I have not touched any of it -- wrong file, not this diff's code, and finishing #7335's conversion belongs in its own change rather than riding along here. I have it written up and am happy to file it separately if you want, ideally checking with the #7335 author first since they chose the replacement shape.

For this PR: a re-run of Backend Tests (Windows) (2) is the cheapest way to settle it. The rest of the head is green so far -- 42 success, 5 pending, that one red.

@chenmingwei23

Copy link
Copy Markdown
Contributor

Two measurements from running this branch against main, offered as information rather than as review asks. Both are against head e4506d473.

1. One over-refusal the storage-time predicate introduces

jq '{a,b}' /tmp/in.json flips from ALLOWED on main to REFUSED on this head.

Mechanism: _CRON_BASH_BRACE_EXPAND_RE is quote-blind, and bash does not brace-expand inside single quotes, so that particular command could never have expanded at run time.

Mitigating context, which is why this is a note rather than a request: it is the fail-closed direction, and it matches how the vet's other rules already behave. awk '{print $1}' is refused on base for the same quote-blind reason, so quote-blindness is the established convention on this surface rather than something introduced here. Recording it as a known cost for you to weigh.

2. The failing Windows lane does not look like it is yours

The Backend Tests (Windows) (2) shard is the only failing check run, and it dies at test/test_denied_commands_security.py:4496 on a wall-clock ratio assertion:

E       AssertionError: 0.0438s -> 0.1351s looks super-linear
E       assert 0.13510329999996884 < (0.04379360000007182 * 3)

That file is not in this diff. It reads as runner-timing flake, so a re-run should clear it, and PR Readiness is likely just reflecting the same red.

@SebastianYuSun

Copy link
Copy Markdown
Contributor Author

Both measurements reproduce. Thank you for framing them as costs rather than asks -- that turned out to be the right call on the first one, and I want to record why with the measurement rather than just agreeing.

1. The over-refusal is real, and slightly broader than stated

Reproduced on e4506d473 vs origin/main, with the double-quoted and unquoted variants added:

command main this head does bash expand it?
jq '{a,b}' /tmp/in.json ALLOWED REFUSED no
jq "{a,b}" /tmp/in.json ALLOWED REFUSED no
jq {a,b} /tmp/in.json ALLOWED REFUSED yes
echo '{a,b}' ALLOWED REFUSED no

So it is not only single quotes -- double quotes suppress expansion too, and three of those four are genuine over-refusals this PR introduces.

Your precedent also checks out as stated: awk '{print $1}' is refused on main by _CRON_POSITIONAL_PARAM_RE, quote-blind, so quote-blindness is the surface's existing convention rather than something introduced here.

2. Why I am keeping it quote-blind rather than fixing the over-refusal

The obvious refinement -- skip braces that sit inside quotes -- is unsafe, because bash performs brace expansion before quote removal. Braces that straddle or contain a quote still expand, while a left-to-right quote tracker would read the region as inert:

echo x{a,b}y      -> 'xay xby'   expanded=True
echo 'x{a,b}y'    -> 'x{a,b}y'   expanded=False   <- only the fully-enclosing case
echo x{a,'b'}y    -> 'xay xby'   expanded=True
echo x{a,b}'y'    -> 'xay xby'   expanded=True
echo 'x'{a,b}'y'  -> 'xay xby'   expanded=True    <- tracker sees "all quoted"
echo x{'a','b'}y  -> 'xay xby'   expanded=True

Four of six expand with a quote inside or adjacent to the braces. The concrete consequence, using a neutral stand-in directory name so nothing sensitive goes in this comment:

$ bash -c "echo '.q'{x,x}'r/data'"
.qxr/data .qxr/data

The literal text carries no .qxr/data substring -- a static scan sees .q'{x,x}'r/data -- yet bash produces the assembled path twice. Substitute a real credential directory for .qxr and the shape is a path-assembly bypass. A quote-aware scanner that skipped '.q' and 'r/data' as quoted regions would admit exactly that. The current quote-blind rule refuses it; I verified the equivalent straddling shapes plus x{a,'b'}y and '{a,b}' are all REFUSED on this head.

Doing it precisely needs a tokenizer that models expansion ORDER, not quote matching, which is a bigger change than this PR should carry and wants its own review. So: accepted cost, kept fail-closed, and written up separately rather than left implicit. If you would rather I add a narrower mitigation, say so and I will -- I did not want to ship a half-measure into a security predicate on my own judgement.

3. On the Windows lane -- agreed on ownership, one correction on "flake"

Same conclusion as yours on whose code it is. I had traced it independently: test_denied_commands_security.py:4496 exercises security._nested_shell_payloads; this commit's four files do not include security.py or that test file, and git log -S on both the assertion text and the code under test names #7122, #7149, #7013, #7356 and #7335 -- none mine. staleness returns REBASE_WONT_HELP.

The one place I would not go as far as "runner-timing flake": I measured it, 20 runs under CPU contention on Linux, and got STABLE 0/20. That is absence of evidence rather than a confirmed flake, so I am recording it as "not reproduced" and leaving the flake question open.

One thing that may be more useful than a re-run: 283625e16 -- "test: assert linearity structurally, not by wall-clock ratio (#7321) (#7335)" -- is already on main, but two wall-clock ratio assertions survived that cleanup, at lines 4496 and 4517. 4496 is the one failing here, at ratio 3.08 against a 3.0 bound. The sibling assert large < 1.0 on the next line is what actually pins the ~13 s quadratic regression, and it passed. Finishing #7335's conversion looks like the durable fix; happy to file it separately, though it may belong with whoever chose the replacement shape.

@github-actions github-actions Bot added the readiness: action required A blocking check or review needs attention label Sep 8, 2026
@SebastianYuSun

Copy link
Copy Markdown
Contributor Author

CI is terminal on 509481e81 now and there are two reds plus the incomplete review lane from my last comment. Neither red is a coverage failure, and no test failed: 56 checks green, 0 pending, all backend and Windows and macOS shards passed.

Root cause, from the job log rather than the rollup. Coverage Combine produced a valid coverage.xml, uploaded all 1,116,978 bytes of it, computed its digest, and then died at the finalize call:

Uploaded bytes 1116978
Finished uploading artifact content to blob storage!
SHA256 digest of uploaded artifact is 871096269fc2...
Finalizing artifact upload
##[error]Failed to FinalizeArtifact: Received non-retryable error:
Failed request: (403) Forbidden: Error from intermediary with HTTP status code 403 "Forbidden"

That is actions/upload-artifact@043fb46d (v7.0.1) failing against GitHub's artifact blob storage, after the coverage data was already computed and transferred.

Coverage Gate is then purely downstream of it. Its env at failure:

CC: failure   BE: success   FE: success   FCM: skipped
ONLY_BACKEND: true   LEAF_TESTS: false   BACKEND_MIN: 90   PER_FILE_MIN: 80
##[error]coverage-combine=failure -- failing closed.

It exited at the dependency check and never evaluated BACKEND_MIN or PER_FILE_MIN against anything. The surface detection was also correct: only_backend=true and frontend-coverage-merge=skipped is exactly the expected shape for this diff.

The 403 is intermittent across the repo rather than a clean outage, which is why I did not stop at "infra, not mine":

PR Coverage Combine completed
#4762 success 16:32:16
#7414 failure (403) 16:38:33
#9435 cancelled 16:38:29
#9453 failure 15:52:12

#4762 succeeded six minutes before mine failed, so I cannot claim the service was simply down.

That left a real unknown, and it is the part worth reading. Because Coverage Gate never ran its comparison, and because this PR's two heads have only ever produced cancelled (concurrency cancellation from your push) and then this 403, no CI run has ever confirmed this diff clears the coverage floor. So "just re-run it" was a hopeful recommendation rather than a safe one until I measured it locally.

Measured against scripts/check_per_file_coverage.py's actual rules:

  • Neither touched module is in .github/coverage-baselines/backend.txt (92 entries, checked), so rule 1 applies to both: they must meet the 80% floor rather than a recorded rate.

  • Every added statement is covered. Intersecting the diff's added line ranges with coverage's uncovered set:

    file added lines statements among them uncovered
    src/kiro_crew/mcp_cron.py 326 80 0
    src/kiro_crew/cron_script.py 93 20 0

    Adding statements that are all covered can only raise a file's rate, so this diff cannot push either module under the floor. (Absolute per-file rates from my run read 73% and 74%, but that is a 12-file subset of the suite and understates them; the added-line figure is the one that answers the question, because it is measured on exactly the tests written for those lines.)

  • The ratchet cannot fire either. Rule 3 turns the gate red when a baselined file is incidentally lifted clear of the floor. Nothing my tests touch is baselined: no security/ module, no shell_normalizer.py, no argv_floor.py, and the largest baselined entries are all under apps/builtins/mochi, dashboard/, and mcp_gateway/, which this diff and its tests never reach.

So once the artifact upload succeeds, the coverage lane should pass on this tree. A re-run of Coverage Combine is the remedy, and a fork contributor cannot trigger one.

On rebasing, which my own tooling recommended and I am declining with a reason. A staleness check flagged REBASE_INDICATED: this branch is 7 commits behind and upstream touched .github/workflows/ci.yml. Following that at file granularity would be wrong here. The implicated commit is b47f1b997 build(deps): bump astral-sh/setup-uv from 9.0.0 to 10.0.1, whose entire diff is that one action pin repeated across 9 workflow files, 17 insertions and 17 deletions. coverage-combine does use setup-uv, which is why the file matched, but the step that failed is actions/upload-artifact further down the same job, and it is untouched. setup-uv installs uv; it cannot affect artifact finalization.

So a rebase cannot fix this, and it would cost you the approval gate you re-armed plus the rebase you just landed. Not doing it.

Nothing to fix in the diff. Asks, both requiring write access:

  1. Re-run Coverage Combine (and Coverage Gate, which will follow it).
  2. Re-run GPT 5.6 Review, per my previous comment: it returned review incomplete on this head, and its displayed blocking comment is a 72b2461e2 verdict whose finding I have measured as closed on the current tree.

@github-actions github-actions Bot added the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Sep 10, 2026
@SebastianYuSun
SebastianYuSun force-pushed the fix/cron-command-shell-brace-off branch from 509481e to 6fa4db8 Compare September 15, 2026 20:29
@SebastianYuSun

Copy link
Copy Markdown
Contributor Author

mechanism: fire-time re-vet applies newly-added refusals to already-stored command jobs

  • Item 4 — deliberate over-refusal, retroactive via the fire-time re-scan

needs-a-decision. The cost is real, and this head makes it marginally larger rather than smaller: closing a measured hole in the same scan adds one refused shape, an unquoted escaped brace such as echo \{a,b\}.
I can bound its edge, though. Measured against real bash, the scan refuses exactly the three characters bash expands across (form feed, vertical tab, CR) and allows exactly the three it does not (space, tab, newline). The over-refusal is therefore a whitespace-free group whose quotes the projection removes, not the whole interval class.
What I cannot close is the half you named: making the release-note commitment verifiable. CHANGELOG.md is off-limits to a feature PR per AGENTS.md, and this account holds pull only, so it can neither label nor assign a tracking issue. A deferral from me would read as tracked and count for nothing, so I am not filing one.
The question, put to you directly: record this as a release-note item you own, or ship the scan exempting a wholly single-quoted group? I recommend the first. That exemption fails open, measured: sh -c 'echo .q{x,x}r' is wholly single-quoted and still expands, and no rule of that shape separates it from grep -E '[0-9]{1,3}'.

@SebastianYuSun

Copy link
Copy Markdown
Contributor Author

mechanism: one line-continuation fold placed ahead of every vet rule

  • Item 5 — rides along: folding also fixes bypasses of five pre-existing rules

rebutted, on the measurement that the fold is not separable from this change. This PR's own brace scan is one of the five rules it protects, so a version without it ships the new gate with a documented bypass.
Proved by removing the fold alone: _has_bash_brace_expansion('echo .q{x.\<newline>.x}r') returns False unfolded and True folded, and real bash expands the split word (.qxr against a +B control of .q{x..x}r). The sequence form needs two characters, so unlike a comma it can be split.
The breadth you are objecting to is therefore one line, not five patches: a single normalisation ahead of the scans, so every rule sees the string the executor will. Fixing only this PR's rule would mean either duplicating that normalisation or leaving the other four bypassable while touching the same function.
I am not claiming the four pre-existing bypasses are in this PR's declared scope. I am claiming they cannot be left out of it without either a known hole in the new gate or a second copy of the same fold.

@SebastianYuSun

Copy link
Copy Markdown
Contributor Author
  • Watch — the fire-time re-scan makes the refusal retroactive on working hosts

needs-a-decision, for the artefact your clear condition names rather than for the finding, which I accept as stated.
Your condition is that the release names the newly-refused shapes and the BRE-escape remedy, or that a linked issue tracks it. Both are outside what this account can produce: it holds pull only, so an issue it opens can carry neither the deferred-finding label nor an assignee nor a due date, and the deferral check answers an issue missing any of the three.
The shapes to name, measured on this head, are: a quoted whitespace-free group whose quotes the projection removes (grep -E '[0-9]{1,3}', sed -E 's/x{2,4}//', jq -c '{a:.x,b:.y}'), and an unquoted escaped brace or separator (echo \{a,b\}). The remedy in the message is the BRE spelling, grep "[0-9]\{1,3\}".
So the list is ready to paste; what I cannot do is put it somewhere the release process will read. Please either take that list into the release notes or apply the label and assignee to an issue I can then reference.

@SebastianYuSun

Copy link
Copy Markdown
Contributor Author
  • Watch — the fire-time re-vet applies the new refusal to the installed base

needs-a-decision. I agree with the trade as you characterise it, and with the objection to where the mitigation lives: a commitment in a PR description is not a commitment the release process can read.
Your clear condition is that the change is recorded where the release PR picks it up — issue label, release-notes draft, or the changelog process's input. All three need write or triage access; this account has pull only. AGENTS.md separately forbids a feature PR from touching CHANGELOG.md, so that route is closed to me by repo rule rather than by permission.
Rather than leave you to reconstruct it, the migration story in one line: the run fails, the job is KEPT, the denial is SEL-audited under cron_command_body, and it does not feed the consecutive-failure auto-pause counter — verified on this head — so a job refused this way stays visible and enabled instead of silently pausing itself.
Please tell me which of the three inputs you want this in, or apply it yourself; I will reference whatever artefact you create.

@SebastianYuSun

Copy link
Copy Markdown
Contributor Author
  • Watch — +B is admitted while the vet gate's composition model is incomplete (extglob)

needs-a-decision. Your reading of the measurements is right, and one correction in your favour: the extglob route is not created by this PR. It is reachable on any host that merely has bash, because a cron command can invoke bash explicitly whatever /bin/sh is. What this PR changes is narrower — it makes bash the default cron executor on the most common distros while the gate models only the forms it models.
Your clear condition is that the gap is filed as a tracked issue referencing this PR's measurements. That is the one thing this account cannot do: it holds pull only, so any issue it opens carries no label and no assignee, and filing an untracked one would misrepresent the gap as tracked.
The content for that issue, so it costs you only the filing: +B disables brace expansion only; extglob composes a path past the gate via BASHOPTS=extglob bash +B -c, needing neither shopt nor eval. A quote-blind refusal of @( +( !( ?( *( would also take awk '!(NR%2)', so the precise fix is teaching _glob_could_reach_credentials about extglob.
If you would rather I not open upstream issues at all, say so and I will leave this as the standing note it is now.

@SebastianYuSun

Copy link
Copy Markdown
Contributor Author

mechanism: one line-continuation fold placed ahead of every vet rule

  • Suggestion — split the four pre-existing line-continuation bypass fixes into their own PR

rebutted, measured rather than argued: the split is not available at the granularity the suggestion assumes, because this PR's own brace scan is one of the rules the fold protects.
Removing the fold alone reopens it: _has_bash_brace_expansion('echo .q{x.\<newline>.x}r') is False unfolded and True folded, and real bash expands the split word (.qxr, against a +B control of .q{x..x}r). A sequence separator is two characters and can be split where a comma cannot.
So a PR carrying the brace gate without the fold ships that gate bypassable, and a PR carrying the fold for only that rule is the same one line of code — the fold is one normalisation ahead of the scans, not five per-rule patches. There is no third arrangement that separates them.
I take the revert-blast-radius point as legitimate and unresolved by the above: reverting this PR would also revert the four pre-existing fixes. If that risk outweighs the coupling, the call is yours, and the honest cost of splitting is a knowingly bypassable new gate.

@SebastianYuSun

Copy link
Copy Markdown
Contributor Author
  • FINDING — fire-time _vet_shell_command denies pre-existing regex-interval command crons

rebutted on the prescription, not on the finding. The mechanism you describe is correct and I reproduced it: a stored grep -E '[0-9]{1,3}' job is denied on every fire, last_status="error", no auto-pause, until it is edited.
Both prescribed remedies fail open, measured. Gating the fire-time refusal on a credential or sensitive-path heuristic reinstates exactly the blindness the scan exists to remove, since a composed word is one a static path check cannot see. Exempting a wholly single-quoted group that no in-command shell re-parses is defeated by sh -c 'echo .q{x,x}r': it is wholly single-quoted, the outer shell consumes the quotes, the inner shell expands it to .qxr .qxr, and no rule of that shape distinguishes it from the grep case.
Surfacing the denial more loudly than the SEL audit line is the reasonable third option, and it is a product decision about a new user-visible surface rather than a defect, so I have not taken it unilaterally.
The code therefore stays as-is. The residual — recording the behaviour change where the release process reads it — is put to the maintainer under the design and first-principles items, since it needs an access level this account does not hold.

@SebastianYuSun

Copy link
Copy Markdown
Contributor Author

Your rebase has been replaced by another one, so here is what changed and the evidence that nothing of yours was lost. Head is now 6fa4db89a, on 3c88aa78d, mergeable=MERGEABLE.

Why another rebase. When you landed yours the branch was ~700 commits behind 9c2b4b67. It had since gone 650 behind again and carried a merge conflict label, so CI had no merge ref to build and the PR could not merge in that state. main moved three more times while this was in flight, which is why the head sits on 3c88aa78d rather than the tip you would have seen.

Nothing of yours was dropped, checked rather than assumed. Comparing the two patches restricted to the touched files, added and removed lines only: 899 delta lines each side, and the sole difference is in the learn-cron-dashboard.md Safety bullet, where this head additionally carries main's newer transient-retry-telemetry paragraph that the older base did not have. Our appended sentence is byte-identical on both sides (same md5). Three files conflicted — windows-install.md, learn-cron-dashboard.md, mcp_cron.py — and each was resolved by taking main's rewritten text and re-applying only our delta. I re-confirmed your check: run_command_sandboxed still calls _command_argv(shell, command).

One of your observations no longer holds on this base, and it matters. You noted that black flags the two touched test files but both are in .github/black-baseline.txt, so it was pre-existing. That was true at 9c2b4b67, where test/test_cron_script_more_coverage.py was line 553 of that baseline. main has since pruned it, so on this base black is a real gate for that file and it is now formatted. Separately test/test_mcp_cron_security.py became black-clean, and the gate asks for a graduated entry to be pruned, so its baseline line is removed.

Your earlier merge blocker is satisfied, measured. You asked for the nested-comma class to be covered before this could merge. The predicate is no longer a regex — it is a counted quote-state scan — and cp ~/.a{w,{w}}s/credentials is refused on this head, as are the alphabetic-range and quote-concatenation classes.

Two holes in this PR's own scan are closed on this head. Both were reachable and neither had been raised:

  • An unquoted backslash escaping the separator or the opening brace. Outside quotes a backslash is the shell's escape character, so quote removal deletes it and a nested shell receives the separator bare. Measured with neutral tokens, /bin/sh +B -c '/bin/sh -c "echo "p{x\,x}q' printed pxq pxq, matching the unescaped control. One spelling carries no quote character at all, so a rule conditioned on quotes being present would still miss it. _strip_shell_quotes now drops an unquoted backslash and keeps one inside quotes, where it survives into the inner shell.
  • A bare } at depth 0 — no quoting, no escape, no nesting, so the cheapest spelling of the three. bash does not close a separator-free group there; it keeps hunting for a later } that has a depth-0 separator before it. echo .a{w},w}s prints .aw}s .aws, and the second word is the credential directory. _scan_one_level now follows bash.

Both are checked by exhaustive differential rather than by example: every word up to six characters over two alphabets, 31,386 and 44,814 bash-accepted words, run under bash -c against bash +B -c and compared with the scan's verdict. Zero expand while the scan allows them, against 15 before. Each guard is proved load-bearing by removing it alone and watching its own assertions fail.

The cost, stated rather than buried. Three over-refusal classes, all fail-closed, all recorded in the measured table's third column: a quoted whitespace-free group (grep -E '[0-9]{1,3}'), an unquoted escaped brace (echo \{a,b\}), and — new with the } fix — a quoted group whose separator arrives in a later argument (awk '{print}' f | grep ',}'). A 38-command realistic corpus is unaffected, including docker ps --format '{{.ID}},{{.Names}}', because a trailing }} decrements depth and never reaches a depth-0 close. The too-complex budget also now trips at roughly 1,000 balanced brace pairs in one command where it previously did not; refusal, not a hang, and the message no longer claims the cause is unclosed braces.

One mechanism I am deliberately not patching, because it is the third occurrence. The quote "state" in this scan is the quote character, not the identity of one quoted run, so a group opened inside '…' skips every byte in a different state — spaces between arguments, and |, ;, && — and a later quoted region can supply its separator and closing brace. That is what refuses awk '{print}' f | grep ',}'. The leak pre-exists both of my fixes; what the } fix changed is that it now starts from any balanced quoted group rather than needing the separator early. Making the state identity-aware is a restructure of the scan, not another special case, and whether this PR should carry that is your call rather than mine.

Two asks still need write access. Coverage Combine failed on a 403 from actions/upload-artifact at the finalize call — infrastructure, and I confirmed it is not a fork limitation because the same account's #7396 passes that lane. GPT 5.6 Review returned review incomplete, and its displayed blocking verdict belongs to head 72b2461e2; that finding's payload measures as refused on this head. This push should re-run both, but every fork lane is currently sitting at action_required, so they need an approval before they produce anything.

@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention merge conflict Branch has merge conflicts with its base — author must resolve before merge readiness: checking Automated validation is still running labels Sep 15, 2026
Command crons were refused outright on any Linux host where /bin/sh is bash
(the default on AL2023, RHEL and Fedora): the POSIX-strict probe accepted only
a shell that preserves `x.{a,a}` when invoked `sh -c`, bash expands it, and
the resolver never looks past /bin/sh and /usr/bin/sh, so installing dash was
not a workaround either. Every command cron failed and auto-paused after five
consecutive failures.

The property the probe defends is real -- the storage-time vet gate tokenizes
the command once, so a runtime re-expansion widens what a deny-list can see --
but bash brace expansion was the one composition form the vet gate never
refused, which left the shell deciding whether the gate held.

- mcp_cron: refuse bash brace-expansion syntax (`{a,b}`, `{1..9}`) at storage
  time, alongside the existing refusals for \$(...), \$'...', backticks,
  non-plain \${...}, positional parameters and loops. The refusal reads QUOTE
  STATE rather than matching a pattern, because bash requires the braces and
  the separator unquoted but not the alternatives: `{w,"w w"}`, `{w,'w w'}`,
  `{w,$'w w'}` and `{w,w\ w}` all expand, so a whitespace-free character class
  would exempt exactly the live shapes. Three properties are load-bearing and
  each was measured, not reasoned:
    * whitespace disqualifies a group only when BARE, and only space, tab and
      newline count -- bash still expands across form feed, vertical tab, CR
      and NBSP, all of which `str.isspace()` calls whitespace. Since the
      disqualifier is what makes the scan ALLOW, a generous whitespace class
      fails OPEN. Bare space is what keeps `awk '{print x, y}'` allowed;
    * nesting is counted, because `{{x}h,h}` expands and stopping at the first
      `}` reads the outer group as separator-free;
    * two levels are scanned -- the command as written, and the command with
      quote delimiters removed, which is what a nested shell receives.
      `bash -c "cat ~/.ss{h","h}/KEY"` puts the separator outside both quoted
      runs while the braces sit inside, so no single-level rule can see it,
      and the inner shell expands the reconstructed word onto the real path.
  The cost is stated in the error text and the docstring: a quoted regex
  interval (`grep -E '[0-9]{1,3}'`) is refused, with the escaped double-quoted
  spelling `grep "[0-9]\{1,3\}"` offered as an accepted BRE equivalent.
- mcp_cron: scan what the shell PARSES, by folding backslash-newline before any
  check runs, using the security module's own exported
  `shell_normalizer._fold_line_continuations` rather than a second spelling of
  it. A continuation is removed before parsing, so it splits whatever token a
  static check matches on and the shell rejoins it afterwards. Every refusal in
  `_vet_shell_command` was bypassable this way, and the un-split spelling of
  each payload was refused as expected -- the credential-path pattern
  (`cat ~/.ss\<newline>h/KEY`, which carries no composition form at all), the
  command-substitution refusal (`$\<newline>(`), the non-plain `${...}`
  refusal, the ANSI-C refusal, and the brace scan's sequence form
  (`{s.\<newline>.s}`, since a comma is one character and cannot be split but
  `..` is two). 7 of the added assertions fail without the folding. POSIX
  requires the removal, so this is not bash-specific -- `sh` resolves the split
  path too. One divergence measured while adopting the shared helper: it also
  folds `\<CR><LF>`, which bash does NOT (bash escapes the CR and lets the LF
  end the command, so `echo a\<CR><LF>b` runs as two commands). For a REFUSAL
  scan that over-folding is fail-closed -- it can only join text the shell keeps
  apart and make this gate see more adjacency -- so adopting it is safe here and
  keeps the divergence in one place instead of two.
- mcp_cron: read quote state through `security.shell_normalizer._iter_shell_chars`
  rather than a private copy of the rules. That generator is THE quote/escape
  machine here and its docstring records the escape a copy gets wrong: inside
  `$'...'` a backslash escapes, so `$'a\'b'` does not close at the escaped
  quote. Measured on `x $'a\'b' {p,q} y`, a hand-rolled copy closed early,
  reopened on the next quote and then disagreed for the rest of the string,
  labelling an UNQUOTED `{p,q}` as single-quoted -- 10 of 17 positions. That
  mislabelling did not open a hole in the brace rule, since the group is
  mislabelled uniformly and the rule compares a group against its own opening
  state, but the continuation normaliser above decides literalness from these
  same states and runs BEFORE the `$'` refusal, so the desync was reachable.
  `_quote_states` is now a thin adapter and the only remaining difference from
  the generator is the quote characters themselves, where this convention
  deliberately reports the state a quote is changing FROM.
- mcp_cron: bound the WORK the brace scan may do, and refuse when the bound is
  hit. The walk is quadratic on a hostile shape -- a long run of `{` with no
  closing brace at the same state makes the inner scan run to end-of-string for
  every one of them. Measured: 145 ms at 1k, 572 ms at 2k, 2.3 s at 4k, 9.2 s at
  8k, i.e. ~4x per doubling, so a few hundred KB hangs the process. A length cap
  alone does not fix it: `cron_add` is capped at 5000 by
  `validation.FieldSpec("command", max_len=5000)`, but `portability.py` re-vets an
  IMPORTED job with the raw dict value where that cap does not apply, and 5000
  still costs seconds once per job. Bounding steps bounds every shape, which is
  the same reason `_CRON_MAX_GLOB_WORD` bounds the word handed to fnmatch rather
  than the command. Exhaustion REFUSES with its own message: no verdict was
  reached, so the command is not clean, and short-circuiting to clean would turn
  a denial of service into a bypass. 2M characters now costs 1.8 s.
- mcp_cron: refuse a command longer than 8192 characters before any per-character
  work runs. The step budget above bounds the brace WALK; it cannot bound what
  `_quote_states` allocates before the walk starts, and on the import path -- which
  vets the raw dict value with no field-length cap, bounded only by the 2 GiB
  uncompressed-archive ceiling -- that allocation is itself the attack: two lists at a
  measured 16.0 bytes/char (flat at n = 1e4, 1e6, 1e7) ask for 32 GiB at that cap. The
  caller's `except Exception` cannot turn it into a dropped job either, because an OOM
  kill is SIGKILL rather than a raised `MemoryError`. The ceiling sits just above the
  5000 a command can be stored at rather than far above it, because a single long WORD
  is quadratic through these rules independently of the brace walk -- measured 133 ms at
  2k, 781 ms at 8k, 11.4 s at 32k and 178 s at 128k, while the brace shape the budget
  does cover stays flat from 156 ms to 269 ms across the same range. That quadratic path
  is PRE-EXISTING: the base commit measures 129 ms / 757 ms / 11.3 s for the same inputs,
  within noise. So this ceiling bounds it to about 780 ms rather than fixing it, and
  64 KiB would have been a bound in name only at roughly 45 s per call. It REFUSES rather
  than truncating, since a truncating scan would vet a prefix and let the executor run
  the whole string.

- mcp_cron: re-run the composition scan at FIRE time for `command` jobs, not
  only at storage time. This is what makes the first half reach the installed
  base: `vet_job_at_fire_time` exists because "a policy tightened AFTER
  scheduling would never be re-evaluated", and it already re-scanned a `script`
  BODY while a `command` body got only the governance ceiling. That asymmetry
  is load-bearing once the resolver accepts a brace-expanding bash -- measured,
  the ceiling ALLOWS `set -B; cat ~/.a{w,w}s/creds` while the storage-time scan
  refuses it, so a command stored before this refusal existed would still run
  after it, on the very executor this change newly admits. Deny semantics at
  that seam are the right ones: the run fails, the job is KEPT, and the refusal
  is audited under its own `cron_command_body` scope, mirroring
  `cron_script_body` -- which also makes a newly-refused shape such as a quoted
  regex interval surface as a legible audited failure instead of silence.
- docs: update the three owning documents in the same commit, which AGENTS.md
  requires. `docs/system-specs/modules/governance.md` enumerated the fire-time
  contract for a `command` job as the capability gate + the `commands` ceiling;
  there is now a third check, and the entry also states why the ceiling and the
  composition scan are distinct decisions that both have to be re-run.
  `docs/guides/windows-install.md` gave brace expansion as the reason Windows
  refuses command crons; that reason is retired by this change, so it now cites
  what the code actually cites -- a shell whose language is wider than the one
  the vet was written against.
  `docs/system-specs/modules/learn-cron-dashboard.md` presented the fire-time
  body re-scan as script-only, which is the asymmetry this change removes, so it
  now states that a `command` body is re-scanned on the same terms and that the
  "denied on every tick until it is edited" property applies to a stored command
  a newly-added refusal rejects.

- cron_script: accept a trusted shell invoked with brace expansion off (`+B`).
  The probe tries the plain form FIRST, so dash/ash/a real POSIX sh keep their
  exact current argv, and the form that PASSED is recorded and re-used by the
  executor through one shared argv builder -- previously the probe and the
  executor spelled argv separately, so the probe could stop proving what runs.

The first half is what makes the second safe: with brace syntax refused at
storage time, a command cannot re-enable expansion and have anything left to
expand. Windows still refuses command crons by design, unchanged.

Every brace row in the tests was run against real bash, comparing `bash -c`
against `bash +B -c` on the same word, and for the nested level comparing
`bash -c 'bash -c "..."'` the same way. The assertion is one-directional: a
shape some shell expands must be refused, a shape every shell leaves literal
must not regress. The one deliberate over-refusal is a SINGLE-quoted group
such as `awk '{a,b}'`, since single quotes survive one level of double-quoted
nesting; the double-quoted spellings are refused for cause, because they
reconstruct into a live expansion.

Not fixed here, and reported on the PR rather than silently widened: brace
expansion is not the only unrefused composition form once bash is the
executor. An extglob pattern such as `.s@(|s)h`, enabled via
`shopt -s extglob; export BASHOPTS` and a nested shell, composes the private
key directory with no `eval` at all, and a pre-set `BASHOPTS` in the
executor's environment needs neither. That is a different composition form with its own
over-refusal cost (`awk '!(NR%2)'`, `awk '{print 2*(x+1)}'`), so it is the
maintainers' scope call, not a change to ride along here.
@SebastianYuSun
SebastianYuSun force-pushed the fix/cron-command-shell-brace-off branch from 6fa4db8 to b6f6827 Compare September 15, 2026 22:00
@SebastianYuSun

Copy link
Copy Markdown
Contributor Author

Fixed the blocking finding, and measuring it turned up something bigger next to it. New head b6f68279b.

F1 — the allocation is real, and the fix was mine to make

Confirmed rather than taken on trust, because the reach matters:

  • _quote_states allocates [None]*n and [False]*n unconditionally. Measured cost is 16.0 bytes/char, flat at n = 1e4, 1e6 and 1e7 — so the 2 GiB _MAX_IMPORT_UNCOMPRESSED ceiling really does imply 32 GiB of lists. "Tens of GB" was exact.
  • portability.py:705 reads job.get("command", "") raw and calls the vet at :711, with no field-length cap. validation.FieldSpec("command", max_len=5000) governs cron_add, not this path.
  • The except Exception at :712 cannot save it. An OOM kill is a SIGKILL; it does not raise MemoryError, so the drop-the-job branch never runs.

The adjudication's other point is the one I should own: the step budget I added bounds the walk, and I described it as bounding every shape. It does not bound the allocation that happens before the walk starts, on the very path I had already identified as uncapped.

Fixed by refusing on length at the top of _vet_shell_command, before the continuation fold (which also allocates) and before any per-character state exists. It refuses rather than truncating: a truncating scan would vet a prefix and let the executor run the whole string.

Why the ceiling is 8192 and not something generous

Following _CRON_MAX_GLOB_WORD's "far above anything legitimate" idiom would have given 64 KiB. Measuring first says that would be a bound in name only, because the step budget does not cover the worst shape in this function:

shape 2k 8k 32k 128k
'{' * n — what the step budget covers 156 ms 163 ms 187 ms 269 ms (flat)
'a ' * n/2 — spaces 34 ms 128 ms 466 ms 1.8 s (linear)
'a' * n — one long word 133 ms 781 ms 11.4 s 178 s

A single unbroken word is quadratic through the rules, independently of the brace walk. At a 64 KiB ceiling that path costs roughly 45 s per call; at 8192 it is ~780 ms. Since a command is capped at 5000 where it is stored, 8192 leaves ~1.6x headroom for a caller with a different cap and still bounds the cost. A test pins storable < ceiling against the real FieldSpec rather than a copy of the number, so raising the storage cap past the scan ceiling fails the build instead of silently making a storable command unscannable.

That quadratic path is pre-existing, not introduced here. Measured on base 3c88aa78d with no patch: 129 ms / 757 ms / 11.3 s for the same inputs, within noise of the branch. So this ceiling bounds it rather than fixing it, and the underlying rule still wants making linear. Per SECURITY.md I have reported that separately through private disclosure rather than describing it further here, since it is an unfixed denial of service on main.

Tests

  • length ceiling refuses, and refuses cheaply — asserted with a timing bound, because a test that only checked for a refusal would also pass with the check placed after the fold and the quote scan, which is the placement that still OOMs;
  • ceiling sits above the storable maximum, pinned against MCP_CRON_SCHEMAS so the two cannot drift;
  • the import path drops an over-length job and keeps its benign neighbour, which is the reach the review named. That fixture was wrong twice before it was right — with {"every": 60} and again without message, rule 1 dropped both jobs, so the assertion passed while proving nothing. Worth saying out loud because a green test that measures nothing is the failure mode here;
  • the existing cost test now uses 2_000/8_000 so both arms stay under the length ceiling and continue to exercise the step budget. Left at 60_000 it would have been decided by length and the budget would have rotted untested.

Boundary is exact: 8192 allowed, 8193 refused by length, and nothing else in the vet reacts to a long run of a.

Gates on the new head: black, isort, flake8 --jobs=1 and mypy src/kiro_crew/ (1539 files) all clean whole-tree, comment-history clean against the base, 624 passed / 6 skipped across the cron, portability and cron-script suites.

The other red: Backend Tests (Windows) (8)

Not this diff, and evidenced rather than argued. Two failures:

  • test_workflows_startup.py::test_dashboard_binds_before_restart_write_and_owns_initialization[False] — asyncio.exceptions.CancelledError
  • test_workflows_service.py::test_finished_run_injects_result_and_autoruns_agent_turn — assert False

Both are already tracked open upstream: #11053 names the first test exactly, and its own cross-link table routes the second to #10964. Both trace to root commit 46034d9a4 (#10586). Neither test file references mcp_cron, cron_script or _vet_shell_command, and this diff touches only those two modules plus three docs and three test files.

I also ran the (d) check rather than skipping to "not mine": git log -S on those paths does name a commit of mine, 5bec0597f (#2283) — but it touched agent_exec.py, agent_pool.py and their own two tests, neither of the failing files, and the failing functions trace to b3c2245a5 and 429cbad8c. So it is not my merged work either.

One precision note: #11053 reports TimeoutError while this run shows CancelledError on the [False] parametrization. Consistent with the issue's description of an asyncio.wait_for gate expiring, since that is how the cancellation surfaces, but not a byte-identical signature. A maintainer re-run is the remedy; there is nothing here for me to patch.

Your two advisory lanes

First principles — item 9 is not right, and it is the one thing I would push back on. It reads "the description never mentions it" about the black reformat and baseline prune. The description does mention it, in the "What changed" section:

test/test_mcp_cron_security.py becomes black-clean, so its line in .github/black-baseline.txt is pruned and the baseline keeps shrinking.

Happy to be told the wording is too buried to count, but it is declared.

Design — the portability.py drop is confirmed, with two refinements. Rule 2 does DROP a job whose command fails the vet (portability.py:714), so "drops such jobs on import" is right. Two things soften the shape of it:

  1. the drop is reported synchronously in the restore summary (summary["rejected_crons"], portability.py:883), not discovered at a missed tick;
  2. rule 3 means every surviving command job is imported paused anyway (:726), so an imported interval cron was never going to fire on its own regardless of this change.

So the import path is the better-signalled of the two. The genuinely unannounced case is the one you and first principles both land on: an in-place upgrade, where a stored job first fails at its next fire. That is the release-notes item, and it is the same ask in both lanes.

Your three named shapes are all really refused, and all three are documented over-refusals rather than new surprises:

shape refused by class
grep -E '[0-9]{1,3}' brace scan single-quoted group, deliberate
jq '{a:.b,c:.d}' brace scan single-quoted group, deliberate
awk '{print}' f | grep ',}' brace scan cross-quoted-run, named verbatim at mcp_cron.py:483

The docstring's mitigating claim for that third class holds on a 21-command realistic corpus: 18 of 21 allowed, and the only three refusals are your own examples. Allowed include all four docker/kubectl format strings ('{{.ID}},{{.Names}}' among them, exactly as the docstring predicts, because the trailing }} decrements depth and never reaches a depth-0 close), sed -n '1,10p', jq -c '{a:.b}', and awk '{print}' on its own.

Two corrections to my own numbers while I was checking yours. The remedy the error text advertises does work — grep "[0-9]\{1,3\}" is allowed; I briefly measured the single-quoted spelling, which is not what the message shows. And awk '{print $1}' is refused by the pre-existing positional-parameter rule, not by the brace scan, so it is not part of this change's cost.

@SebastianYuSun

Copy link
Copy Markdown
Contributor Author

Both lanes have now re-reviewed b6f68279b. GPT's block is cleared and the remaining two are advisory, so this is a reply rather than a push.

Design — your auto-pause point is right, and it is right for a reason worth stating

I checked the load-bearing half rather than taking it:

The refusal is permanent-until-edited and does not feed auto-pause

Confirmed, and it is deliberate. CronClaimTimeDenied's docstring in
src/kiro_crew/slack/gateway.py says the class exists partly so a governance denial is handled before the generic except Exception arm,

which calls record_failure() and would feed a policy decision into the auto-pause counter.

Meanwhile consecutive_failures (cron.py:758) is "consecutive failed runs (any error); drives auto-pause", with _AUTO_PAUSE_THRESHOLD = 5 (cron.py:376). So the generic path would pause such a job after five ticks, and the vet-denial path opts out on purpose, on the reasoning that a policy refusal is not a defect of the job.

That makes your second clears-when branch the right shape rather than a nicety. Auto-pause is the mechanism that would otherwise surface this, and it is intentionally excluded, so something else has to. I have written the sweep up as its own item rather than building it here: read stored command bodies at boot (or once per upgrade marker), run the current vet read-only, and report the set that would now be refused with each reason — explicitly not pausing, editing or dropping anything, since the refusal already denies at fire time and the gap is announcement rather than enforcement. Building an upgrade-sweep inside a cron-availability fix is the coupling your own lane has objected to elsewhere in this review, so I would rather it be a separate change you can judge on its own.

The other branch (release notes naming the newly refused shapes and remedies) is tracked at #9488, so the Watch item has a satisfiable path either way.

On the Suggestion — fair, and I would not defend the current state. _BRACE_SHAPES_MEASURED_AGAINST_BASH pins the scan; only a human re-running the enumeration pins the table. If a future bash changes a shape's expansion, every test still passes because they compare against the recorded column, so the gate would be wrong and silent. That is the real asymmetry and your framing of it is correct.

Also parked rather than added, for the reason your own wording anticipates: the enumeration needs a real bash and the answer legitimately varies by version, so as a blocking pull_request test it would fail contributors whose host bash disagrees, which is not a defect of their diff. Scheduled, bash-gated and report-only is the right form, and that makes it a workflow change rather than a test change. Sketch in the parked note: enumerate short words over {, }, ,, . plus a literal, compare bash -c against bash +B -c, assert the scan refuses every word where they differ, record the bash version so a divergence is attributable, and do the same at the nested level since that is where the cross-quote class lives.

First principles — thank you for item 6; item 10 is still not right

Item 6 is the fix from this round and I am glad it reads as justified.

Item 10 says the black reformat and baseline removal are "never mentioned in the description". They are, and I checked the live body again after this round's edit specifically in case my own update had dropped the sentence. It had not — lines 156-157 of the current body:

test/test_mcp_cron_security.py becomes black-clean, so its line in .github/black-baseline.txt is pruned and the baseline keeps shrinking.

This is the second round the item has appeared, renumbered from 9 to 10 as the inventory grew. If the objection is that a two-line note inside "What changed" is too buried to count as declaring formatting churn, say so and I will pull it out into its own line — that is a reasonable ask and an easy change. But as written the item asserts something absent that is present, and I would rather flag that than quietly accept it.

For what it is worth on provenance: that reformat arrived in 6fa4db89a, which the formatting gate required once the file was touched — scripts/check_black_formatting.py flags a changed file as a new offender unless it is baselined, and making it clean is what then obliges pruning its baseline line. So it is gate-mandated rather than discretionary, which I think is also what "formatting-gate mechanics only, no behaviour" is getting at.

State

CI on this head: 48 green, 0 failed, 27 still running. The 6 cancelled entries are concurrency cancellations from the superseded head; if PR Readiness reports blocking items with zero failed check-runs, that is the workflow-run arm counting those cancellations, and it clears on the next full cycle rather than needing a code change.

@SebastianYuSun

Copy link
Copy Markdown
Contributor Author

Two reds on b6f68279b, neither one a code problem, and one of them requires me to withdraw a claim I made here a week ago.

E2E (stub ACP backend, offline) — already tracked as #10919

The real error, from the job's annotations after the log endpoint returned nothing usable:

test/e2e/test_private_workflow_memory.py::test_private_workflows_execute_over_real_projected_mcp
AssertionError: {'agent_error_count': 1, 'agent_errors': {'1':
  'RuntimeError: memory_unavailable: cannot verify protected memory hardlink...

That is #10919 — "Private-memory spawn fails intermittently when a concurrent transcript write races the hardlink scan", open, filed 2026-09-15. I did not reach for that by keyword: #11053's own body routes this exact symptom there, calling it "a real shippable defect rather than a CI artifact" split out of the #10878 family.

Attribution checks run rather than assumed:

Worth noting for triage: this is now the third distinct symptom from the 46034d9a4 family to land on this PR, alongside #11053 and #10964 on the Windows lane. That commit is doing a lot of work in your flake budget.

GPT 5.6 Review — review incomplete, and my earlier explanation for it was wrong

I owe a correction. On 2026-09-08 I posted a measured hypothesis here: that the lane's review incomplete outcome tracked this PR's growth, since the two incomplete heads had a 73 KB diff and a 2053-character line while the two that produced real reviews had 31 KB and 93 characters. I said I could not separate diff size from line length, and offered wrapping the long lines and shrinking the commit message as a remedy.

A counterexample has since arrived and it falsifies all of it. Adding the two heads from today:

head diff longest added line run duration verdict
898d19868 20 KB 93 9m18s changes requested
72b2461e2 31 KB 93 16m05s changes requested
27f1118a0 73 KB 2053 15m10s review incomplete
509481e81 73 KB 2053 9m10s review incomplete
6fa4db89a 91 KB 2954 11m17s changes requested
b6f68279b 103 KB 2954 10m07s review incomplete

6fa4db89a is larger than 27f1118a0 on both axes I had implicated — 91 KB against 73 KB, a 2954-character line against 2053 — and it completed a full review, the one that produced the allocation finding I fixed. Duration fails as a predictor too: 9m18s completed while 9m10s did not, and 16m05s completed while 15m10s did not.

So across six runs there are three completions and three incompletes with no monotone relationship to diff size, line length or duration. That is the signature of an intermittent condition on the lane rather than a property of this diff, and it means the remedy I offered a week ago would not have helped. Withdrawing it: there is nothing here worth reshaping the diff for, and I am glad not to have force-pushed a cosmetic rewrap on that theory.

What I can still say with evidence is narrow and worth keeping separate from the above: when the lane DOES complete, its findings on this PR have been correct both times, and the one from 6fa4db89a is fixed and verified on the current head.

Asks

Both are re-runs, and neither is actionable from a fork:

  1. re-run E2E (stub ACP backend, offline) — or leave it, if Private-memory spawn fails intermittently when a concurrent transcript write races the hardlink scan #10919 is understood to be flaky enough that a red here carries no information;
  2. re-run GPT 5.6 Review, which is the only experiment that distinguishes an intermittent lane from a persistent one, and is free.

Everything else on this head is green: 59 success, 0 other failures, 15 still running at the time of writing. The 6 cancelled entries are concurrency cancellations from the superseded head.

@github-actions github-actions Bot added the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Sep 21, 2026
@bolichen97

Copy link
Copy Markdown
Contributor

Superseded by #15253, credited per CONTRIBUTING's superseding rule: your commit is cherry-picked with its authorship unchanged (commit 1), and the one added commit carries your Co-authored-by trailer.

Why a replacement rather than updating this branch: it is ~1,870 commits behind main and conflicting in five files. Bringing it current in place would mean force-pushing your branch or adding a merge commit, and the merge commit fails PR Hygiene. The conflict resolutions are listed in #15253 (the main one: main wrapped the executor spawn in the app-secret mask, and only the argv line changed to _command_argv).

What #15253 adds on top of your change:

  • The no-shell refusal is now worded per platform. On macOS and Linux it said "Windows ships no such shell", which is how this surfaced again on macOS, where /bin/sh is bash in POSIX mode.
  • A real-bash test that runs the probe against bash invoked as sh (POSIX mode).

If you come back to this and would rather land it here, say so and I will close #15253 instead.

Copy link
Copy Markdown
Contributor

Open-PR triage (2026-10-05): SUPERSEDED, closing

I checked the code itself, not just the PR description. This PR's change is on main as #15253 (PR, merged 2026-09-30, 0d2d25af94). #15253 cherry-picks commit b6f68279b with the author unchanged. #15344 (PR, merged, 481476a109) then extended the brace scan.

Evidence (origin/main af1eb612da66):

  • src/kiro_crew/cron_script.py:2737-2835: _POSIX_STRICT_CACHE, _BRACE_OFF_SHELLS, _BRACE_OFF_FLAG = "+B", the shared _argv_for_form/_command_argv builder, and _shell_is_posix_strict trying for brace_off in (False, True) through _probe_one_form. This matches the PR's probe/executor design.
  • src/kiro_crew/mcp_cron.py: the quote-state brace refusal (_quote_states) inside _vet_shell_command. Line 1614-1618: the fire-time re-vet of command jobs, audited under cron_command_body.
  • docs/system-specs/modules/learn-cron-dashboard.md:585 and governance.md carry the PR's spec text.
  • I diffed every line this PR adds against 0d2d25af94. Of 1006 distinct added lines, 991 appear verbatim. The other 15 are re-indented or reworded versions of the same logic: the conflict resolution with the app-secret mask wrapper, as stated in fix(cron): run command crons where /bin/sh is bash, incl. macOS #15253.

Nothing in this branch is left unlanded, so I'm closing it as superseded. The branch is also ~1,870 commits behind with conflicts in five files. If something here is not on main, reopen the PR and say what it is.

@bolichen97 bolichen97 closed this Oct 5, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

fork Pull request from a fork (external contributor) merge conflict Branch has merge conflicts with its base — author must resolve before merge

Projects

None yet

Development

Successfully merging this pull request may close these issues.

command crons are refused on Linux hosts where /bin/sh is bash (POSIX-strict probe has no accepted form for a brace-expanding trusted shell)

4 participants