Skip to content

fix(env): reload .env credential changes without a gateway restart - #23514

Closed
RohanK6 wants to merge 2 commits into
mainfrom
env-hotreload-22450-v3
Closed

RohanK6 wants to merge 2 commits into
mainfrom
env-hotreload-22450-v3

Conversation

@RohanK6

@RohanK6 RohanK6 commented Oct 23, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: An edit to $KIROCREW_HOME/.env takes effect on a running gateway, restarting only the affected channel, without a full gateway restart.

Edits to $KIROCREW_HOME/.env took effect only after a full gateway restart. The live config watcher fingerprinted config.json only, and nothing re-read .env after boot. The dashboard's own credential writer applied its changes live, but a hand edit or any other writer did not, so a rotated token kept reading as the old value until someone restarted the gateway.

Why it matters

Operators rotate channel credentials by editing .env. Today the edit silently does nothing until a restart, so a revoked token keeps a channel failing to authenticate, and a new token looks "saved" but is not in force. Requiring a full restart for a credential change also drops every running session.

Not a goal

  • Hot-swapping a Slack token in place. Slack's client is host-managed with no in-process restart path, so a Slack token change logs a "run kirocrew restart" notice instead.
  • Pushing a new environment into already-running children (ACP sessions, MCP servers). They keep their environment until they respawn.
  • Changing which keys .env supports or how boot reads it.

What changed (motivation → approach → change)

Symptom: a .env edit is ignored until restart. Root cause: ConfigWatch never watched .env. Change: .env is reconciled in the same poll cycle that already reloads config.json.

operator edits $KIROCREW_HOME/.env
        │
        ▼
ConfigWatch._cycle()  ── same poll that already reloads config.json
        │
        ├─ env_fingerprint(.env) unchanged → nothing to do
        │
        └─ env_fingerprint(.env) changed
                │
                ▼
        read_env_credentials_raw()       (off-loop, permission-checked)
        _prepare_path_additions()        (off-loop: PATH expand + validate)
                │
                ▼
        diff vs baseline (seeded once at boot from the raw map
        load_credentials() actually read, not a later disk read)
                │
                ├─ validate every changed key first (atomic batch)
                │
                ▼
        apply_env_credential_changes()   (on-loop: os.environ mutation only)
                │   set/pop os.environ, honouring the Docker scrub and PATH carve-outs
                │   pop only what .env itself propagated (ownership is recorded)
                │
                ├─ success → advance fingerprint + baseline
                │            dispatch credentials.<KEY> (+ Teams restart_credentials)
                │                     │
                │                     ▼
                │            restart_channel() re-reads load_credentials()
                │            (Slack: host-managed → "run kirocrew restart" notice)
                │
                └─ failure → leave fingerprint + baseline untouched
                             next tick retries the whole diff
  • After boot, every gateway-side credential read (channel reconnect, readiness badge, jira/doctor/upload-destination) uses load_credentials(propagate=False), so a worker-thread read cannot reseed a credential the watcher just removed.
  • The dashboard's credential writer now goes through the same apply_env_credential_changes instead of its own set/pop loop, so it also respects the Docker credentials scrub.
  • A .env PATH line is expanded and validated off the event loop (env.prepare_env_path_additions, run via asyncio.to_thread) and handed to the applier as path_additions. A ~otheruser entry calls pwd.getpwnam / the SAM database, and that lookup no longer runs on the loop. os.path.expanduser semantics are unchanged.
  • A live set records .env ownership only when the write takes the entry over (a new key, a rotation, an overwrite of a foreign value, or a key .env already owns). A line whose value merely matches what the process inherited from a service unit or shell is not owned, so removing it later leaves the inherited credential in place, as boot's setdefault already does.
  • The applier decides per os.environ ENTRY rather than per .env spelling. On Windows (case-insensitive os.environ) every spelling of a key (HTTPS_PROXY / https_proxy) is grouped and resolved once, to the first non-empty spelling in .env order (boot's setdefault precedence), so a rename, a partial duplicate removal, or both spellings edited in one save cannot leave the entry depending on iteration order. On POSIX each entry has one spelling, so nothing changes there.
  • The watcher's diff (changed_env_keys) also compares each entry's effective value, so a Windows save that only reorders two spellings with different values is applied instead of silently adopted as the new baseline.
  • The Weixin QR sign-in writes its token through the same apply_env_credential_changes as the dashboard channel writer, so it records .env ownership (a later removal of the line revokes it in-process) and keeps the Docker scrub guard.
  • The Weixin QR sign-in's .env + config.json commit runs under live.hold() (like every sibling channel saver) and through drained_to_thread, so the watcher never restarts Weixin between the two writes and a cancelled request never releases the hold mid-write.
  • The boot .env record is tied to the file it was read from: the watcher adopts it only for the same .env, so a record from another data home is never taken as its baseline.
  • Teams: closing the client on a credential removal also clears its bound webhook handler and returns 503 for a request already past the close check, because the inbound route stays registered independently of the client. A tenant-only edit restarts Teams through a new restart_credentials descriptor field.
  • Teams: the webhook handler (state.teams_on_activity) is bound only once a client is the accepted handle, after boot's start_channels and after a restart passes its generation check. maybe_start_teams no longer binds it before the connect completes, so a restart superseded mid-connect never exposes its handler (the route answers 503 until then).
  • Slack: the restart-needed notice matches credential keys by canonical entry name, the same rule as registry.changed_credential_keys, so a lowercase .env Slack key on Windows still gets the notice.

This supersedes #23027, #23470 and #23491 (all closed). Same reviewed change as one commit on current main, so PR Hygiene's commit limit is met without a force-push. It also registers the two new helpers with the structural guards (config.loader's facade manifest and the gateway composition inventory), which #23491's CI flagged. The second commit fixes the two review findings raised on this PR.

Backwards compatibility

Compatible: boot still seeds .env with setdefault, every key .env accepted before is still accepted, and PATH entries resolve exactly as before.

Removes nothing: the diff adds a watcher input and routes existing credential writes through one applier; no key, kind, public function or stored data is removed or renamed.

Reader: src/kiro_crew/dashboard/messaging_api/channel_config_writes.py:write_channel_env -- crew page -- under _KIROCREW_CREDS_SCRUBBED a dashboard save no longer writes credential keys into os.environ, matching the boot loop; children read them from .env (test_a_landed_write_honours_the_docker_creds_scrub)

Tests

Proof: PROVEN test/test_channel_boot_hot_reload.py::TestTeamsCloseClearsWebhookHandler::test_closing_teams_clears_the_late_bound_webhook_handler, test/test_channel_boot_hot_reload.py::TestTeamsWebhookPublishedOnlyForTheAcceptedClient::test_an_accepted_start_binds_its_handler, test/test_channel_boot_hot_reload.py::TestCredentialChangeRestartsChannel::test_a_credential_change_restarts_the_owning_channel, test/test_channel_boot_hot_reload.py::TestCredentialChangeRestartsChannel::test_a_credential_change_for_a_degraded_channel_is_deferred_not_dropped, test/test_channel_boot_hot_reload.py::TestSlackCredentialChangeWarns::test_a_slack_token_change_logs_a_restart_needed_notice (head 58e9b2e)

  • test/test_env_credential_hot_reload.py: an env-only edit dispatches credentials.<KEY> and applies os.environ; a failed apply leaves the baseline so a repair re-applies the rotation; an undecodable or wide-encoded .env is retried rather than read as every key cleared; a removal pops only what .env propagated; a .env PATH edit is expanded on a worker thread, not the loop thread; a Windows case-duplicate keeps its entry when one spelling is removed; a live add that matches an inherited value does not take ownership, so deleting the line keeps the inherited token, while an add that writes a new value does own it and is popped on removal; both spellings edited in one save resolve to boot's precedence in either iteration order, modelled with a case-folding os.environ; a reorder of two Windows spellings with different values is a diff and installs the new winner, while a reorder of equal values is not.
  • test/test_dotenv_path_extension.py: a .env PATH line appends absolute directories behind the existing PATH, deduped; relative and unexpanded entries are dropped with a warning; ~ and ~otheruser still expand through os.path.expanduser.
  • test/test_channel_boot_hot_reload.py: a credential change restarts only the owning channel; a degraded channel's change is deferred, not dropped; a Slack token change logs the restart notice; closing Teams clears the late-bound webhook handler; a Teams restart superseded mid-connect never binds its webhook handler while an accepted one does; a lowercase Slack key on Windows still logs the notice.
  • test/test_weixin_qr.py: a first sign-in records ownership, so deleting the line afterwards revokes the token in-process; a confirmed sign-in persists while the watcher is held and a cancelled one keeps the hold until the write finishes; a boot record from another .env file is refused.
  • test/conftest_resets.py: the boot .env record and the ownership set are reset around every test, so neither leaks across an xdist worker.
  • test/test_teams_gateway.py: maybe_start_teams registers the transport but leaves the webhook handler unbound for the host.
  • test/test_channel_env_write_off_loop.py: the dashboard writer honours the Docker credentials scrub.

Local on head 58e9b2e284 (Python 3.12): 4022 passed across every test file touching credential loading, the watcher, ownership or Weixin, plus the facade-mirror, gateway-bindings, composition-contract, loader-owners and flake-ratchet guards; isort and flake8 clean on every changed Python file; mypy clean on all 27 changed source modules; scripts/check_black_formatting.py gate passes; flake-pattern ratchet passes against the merge base.

Manual verification

N/A — the watcher cycle, applier, and channel restart dispatch are each driven end to end by the ConfigWatch._cycle() tests above against a real temp .env, which is the path a hand edit takes.

Related Issues

Fixes #22450

Sibling sweep

Swept: git grep -nE "load_credentials(|apply_env_credential_changes|os.environ[.*] *=" -- src/
Sibling: src/kiro_crew/dashboard/messaging_api/channel_config_writes.py -- changed here
Sibling: src/kiro_crew/slack/gateway_runtime/channel_lifecycle.py -- changed here
Sibling: src/kiro_crew/dashboard/source_providers/jira.py -- changed here
Sibling: src/kiro_crew/dashboard/upload_destination.py -- changed here

Pattern harvest

Not generalizable: the defect was one missing watcher input (.env alongside config.json), not a repeated code shape a rule could catch.

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title (feat|fix|docs|style|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) — docs/system-specs/modules/config.md
  • No secrets, credentials, or internal references in the diff

Contribution License Agreement

Contributed under the project's Apache-2.0 license.

…22450)

Edits to $KIROCREW_HOME/.env took effect only after a full gateway
restart: the live config watcher fingerprinted config.json only and
nothing re-read .env after boot. The dashboard's own credential writer
applied its changes live, but a hand edit or any non-dashboard writer
did not.

ConfigWatch now reconciles .env in the same cycle that reloads
config.json. It tracks a separate env fingerprint
(loader.env_fingerprint), kept out of _config_fingerprint because that
one is the parsed-config cache key. On an .env change it re-reads the
raw credential map off the loop, diffs it against a baseline, and
pushes changed keys into os.environ (set/pop), dispatching the same
path a synthetic credentials.<KEY> change takes so the channel-restart
applier restarts only the channels whose descriptor credentials
changed (restart_channel, which re-reads load_credentials). Slack is
host-managed with no in-process restart path, so a Slack token change
logs a restart-needed notice instead. Teams gains a restart_credentials
descriptor field for keys (the tenant id) that are restart-relevant but
not required for readiness, since folding the tenant into `credentials`
would wrongly report multi-tenant Teams as un-startable.

Diff semantics, built up across review rounds and pinned by tests:
- A removed key is popped from os.environ only when the current value
  still equals what .env last propagated, so an inherited shell/systemd
  value a removal never set is left alone.
- The overwrite warning fires only on a genuinely foreign value
  collision, not on every routine rotation.
- The watcher's diff baseline is seeded from the raw .env map the
  first boot-time load_credentials() actually read (recorded once,
  consumed once), not a later disk read, so a credential rotated in
  the boot window is still diffed and applied instead of silently
  adopted as the new baseline.
- The fingerprint and baseline only advance after an apply succeeds;
  a failed apply (e.g. a malformed `=value` line in the same write as
  a real rotation) leaves both untouched so the next tick retries the
  whole diff, and the apply validates every key before mutating
  anything so a batch is atomic.
- Every post-boot credential read (channel reconnect, readiness badge,
  jira/doctor/upload-destination readers) now calls
  load_credentials(propagate=False), so a worker-thread read can no
  longer reseed a credential the live watcher just removed. The
  dashboard's own credential writer routes through the same
  apply_env_credential_changes instead of hand-rolling os.environ
  set/pop, so it inherits the Docker-scrub skip and PATH carve-out.
- A non-BOM decode error on .env is treated as non-definitive (warned
  once, retried) instead of wedging the watcher permanently.
- Teams: a credential removal closes the live client but its inbound
  webhook route stays registered, so TeamsClient now re-checks
  "closed" after the processing awaits (not just at entry) and 503s
  once closed; closing clears the bound activity handler.

Adds loader helpers (env_fingerprint, read_env_credentials_raw,
changed_env_keys, apply_env_credential_changes,
record_boot_raw_env/take_boot_raw_env) and
registry.changed_credential_keys (case-insensitive on Windows), plus
tests for the loader helpers, the watcher's .env tracking and boot-
window baseline, the credential-driven channel restart, and the
Teams webhook-after-close race.

Later review rounds, folded into this commit:
- A .env PATH line is expanded and validated off the event loop
  (ConfigWatch._prepare_path_additions -> env.prepare_env_path_additions,
  run via asyncio.to_thread) and handed to the applier as path_additions,
  so a ~otheruser entry's pwd.getpwnam / SAM lookup never blocks the loop.
  os.path.expanduser semantics are unchanged.
- The applier decides per os.environ ENTRY, not per .env spelling: on
  Windows (case-insensitive os.environ) all spellings of a key are grouped
  and resolved once, to the first non-empty spelling in .env order (boot's
  setdefault precedence), so renames, partial duplicate removals and
  both-spellings edits are no longer order-dependent.
- Ownership is recorded only when a write takes the entry over (new key,
  rotation, overwrite of a foreign value). A line that merely matches an
  inherited service/shell value is not owned, so removing it keeps the
  inherited credential.
- Teams: the webhook handler (state.teams_on_activity) is bound only once
  a client is the accepted handle (after boot's start_channels, and after
  a restart passes its generation check), so a restart superseded
  mid-connect never exposes its handler.
- Slack: the restart-needed notice matches credential keys by canonical
  entry name, like registry.changed_credential_keys.
- The watcher's diff (changed_env_keys) also compares each entry's
  effective value, so a Windows save that only reorders two spellings with
  different values is applied rather than adopted as the new baseline.
- The Weixin QR sign-in writes its token through apply_env_credential_changes
  like the dashboard channel writer, so it records .env ownership (a later
  removal revokes it in-process) and keeps the Docker scrub guard.
@github-actions

github-actions Bot commented Oct 23, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Opus 5.5) — ✅ PASS

Design-level review of 58e9b2e2845a9bd3e7f58f1ba6a6bed19f6e5732 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

Design-Verdict: PASS

Nothing blocks: the change fixes the root cause by adding .env to the existing watcher cycle, it is backend-only, and a revert undoes it cleanly.

Notes

  • The Teams webhook rebinding and the Weixin live.hold() changes are hardening for the credential-restart path, not the watcher itself. The diff is large; if a later review round reopens either one, split it into its own PR so the .env watch can land without it.

[DESIGN-REVIEWED] 58e9b2e

Description read

[DESCRIPTION-READ] 0ef0c270f7d544a3c79ac7b3b7ace992a4e8c94c27a9fb0496022e51fd20b2ce

That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions

github-actions Bot commented Oct 23, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Opus 5.5) — ✅ PASS

UX-level review of 58e9b2e2845a9bd3e7f58f1ba6a6bed19f6e5732 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

UX-Verdict: PASS

Nothing to check. The change is backend-only: it touches nothing under website/, adds or changes no control, and its only new text goes to the gateway log. So the missing screenshot leaves no evidence gap.

[UX-REVIEWED] 58e9b2e

Description read

[DESCRIPTION-READ] c98c70be66c641b72dc4a3c755efb3ace675f9c5e0d6d0dab9f353784641a4f7

That sha256 names everything this verdict read: the PR description, plus the 3 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions

github-actions Bot commented Oct 23, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Opus 5.5) — ✅ PASS

Premise-level review of 58e9b2e2845a9bd3e7f58f1ba6a6bed19f6e5732 — why this exists and whether the shipped surface is the smallest honest version. Updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

First-Principles-Verdict: PASS

Nothing blocks. Every item follows from the reported defect (hand edits to .env were ignored until a restart) or from the live apply that fixes it. Two items are larger than they need to be.

Notes

  • Item 7 — one consumer, generalized: the new descriptor field restart_credentials: tuple[str, ...] = () is set only by Teams (channels.py:113; grepping restart_credentials finds 1 constructor site). Subtraction: drop the field and give the Teams tenant key to changed_credential_keys directly. The tuple can return when a second channel needs it.
  • Item 6 — undeclared: _carry_env_ownership_across_reexec adds a re-exec environment marker that survives restarts. The description never mentions it. Subtraction: defer it. Without it, a .env removal right after an in-app restart leaves the inherited value in place, which is what boot's setdefault already does.

What this change ships

Inventory (10 items) — 8 justified

Intent: when someone edits .env, the running gateway uses the new credential and restarts only the affected channel. FIX.

  1. A hand edit to .env now reaches the running gateway within one poll — justified
  2. A changed credential restarts only its channel; for Slack a key change logs a "run kirocrew restart" notice — justified
  3. Removing a .env line clears only values .env itself set, never inherited ones — justified
  4. Dashboard channel saves now respect the Docker credential scrub — justified
  5. Credential reads after boot no longer write back into the environment (propagate=False) — justified
  6. .env ownership is carried across an in-app restart through an environment marker — undeclared
  7. Editing only the Teams tenant now restarts Teams — one consumer, generalized
  8. Teams answers 503 once its client is closed; its webhook is bound only after the client is accepted — justified
  9. The Weixin QR sign-in writes through the shared applier under live.hold() — justified
  10. Windows: when a key appears in several cases (HTTPS_PROXY / https_proxy), the variants are grouped and resolved once — justified

[FIRST-PRINCIPLES-REVIEWED] 58e9b2e

Description read

[DESCRIPTION-READ] 8945d14bfbc02a2a13c13488fafd6121a0d73d55e0208c21cad9d08ecccaedbb

That sha256 names the PR description this verdict read. Recompute it with .github/scripts/pr-description-capture.sh; if it differs, the description changed after this verdict was formed and any finding drawn from the description is unproven.

@github-actions

github-actions Bot commented Oct 23, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5.5 Review — ✅ no blocking findings

Reviewed 58e9b2e2845a9bd3e7f58f1ba6a6bed19f6e5732 — this comment is updated in place on each push.

Review details

No findings.

[OPUS-REVIEWED] 58e9b2e

Verdict parsed from the review's SHA-scoped output markers for commit 58e9b2e2845a9bd3e7f58f1ba6a6bed19f6e5732.

False positive or not applicable? A repository writer can comment:
/ai-review override fable 58e9b2e2845a9bd3e7f58f1ba6a6bed19f6e5732: <one-sentence reason>

@github-actions

github-actions Bot commented Oct 23, 2026 •

Copy link
Copy Markdown
Contributor

GPT 6.1 Review — 🔴 changes requested (blocking)

GPT 6.1 found at least one blocking issue that must be resolved before merging 58e9b2e2845a9bd3e7f58f1ba6a6bed19f6e5732. Adjudication upheld 2 of 2 blocking finding(s); those must be resolved before merging.

This comment is updated in place on each push.

BLOCKING -- src/kiro_crew/dashboard/server.py:1450 -- Keep the data-scaled migration off the readiness path

await asyncio.to_thread(migrate_existing_crewmates, cfg)
Trigger: Gateway startup calls run → _init_dashboard → start_dashboard, which awaits migration before setting state.ready and returning to the readiness announcement.
Outcome: Every launch waits for the migration’s crewmate-file scan and thread-record reconciliation; startup latency grows with stored data even though the work runs off-loop.
Anchor: no-new-work-on-gateway-boot-path
Fix: Move migration and its dependent restoration into tracked post-readiness work, keeping dependent operations unavailable until it completes.

BLOCKING -- test/test_weixin_qr.py:641 -- Replace the cancellation timing barrier with a signal

await asyncio.sleep(0.1)
Trigger: The cancellation test starts slow_commit, cancels the request, then sleeps before checking the hold; an event-loop scheduling delay exceeding the worker’s ten-second wait lets the write finish first.
Outcome: Correct cancellation-safe code fails the “still in flight” assertion because of runner scheduling rather than handler behavior.
Anchor: tests-are-deterministic
Fix: Await a bounded signal proving cancellation reached the drain, keep the worker parked until explicitly released, and release it in finally.

[BLOCK-MERGE] 58e9b2e
[GPT-REVIEWED] 58e9b2e

Adjudication (Opus 5.5) — is blocking on each finding proportionate?

F1 — MEDIUM harm (boot latency). src/kiro_crew/dashboard/server.py:1450 awaits migrate_existing_crewmates before the restores and readiness, and server.py is covered by rule no-new-work-on-gateway-boot-path, which carries blocking: true (.review-base-rules/AUTOSDE.yaml:141-146). Note for humans: server.py is not in this PR's diff (git diff HEAD^1 HEAD --name-only); the line comes from the base branch, so a writer override is the right way to clear this. The rule's flag still outranks my weighing.
F2 — LOW–MEDIUM harm (a flaky test). test/test_weixin_qr.py:641 uses await asyncio.sleep(0.1) as the barrier before checking not task.done() and the hold depth, and the worker's release.wait(timeout=10) at :630 limits how long that window stays valid. Rule tests-are-deterministic is blocking: true (.review-base-rules/AUTOSDE.yaml:369-370). The fix is cheap: wait on a signal instead.

[ADJUDICATION] 58e9b2e2845a9bd3e7f58f1ba6a6bed19f6e5732 total=2 uphold=2 downgrade=0
UPHOLD F1 src/kiro_crew/dashboard/server.py:1450 reason=autosde-blocking-rule
UPHOLD F2 test/test_weixin_qr.py:641 reason=autosde-blocking-rule
[GPT-ADJUDICATED] 58e9b2e2845a9bd3e7f58f1ba6a6bed19f6e5732

False positive or not applicable? A repository writer can comment:
/ai-review override gpt 58e9b2e2845a9bd3e7f58f1ba6a6bed19f6e5732: <one-sentence reason>

@github-actions github-actions Bot added the readiness: action required A blocking check or review needs attention label Oct 23, 2026
….env record

Weixin: the QR sign-in commits .env and then config.json without holding
the live-config watcher, so a poll between the two writes could restart
Weixin with the new token and the previous account id. The persistence now
runs under live.hold(), like every sibling channel saver, and through
drained_to_thread so a cancelled request never releases the hold (or the
config lock) while the write or its rollback is still in flight.
(GPT 6.1 Review blocking finding.)

Boot record: the raw .env map the first load_credentials() reads is now tied
to the file it came from, and the watcher adopts it only when it watches that
same file. A record taken in another data home is discarded rather than
diffed against this one. The root test conftest also resets the boot record
and the ownership set around every test, so neither leaks across an xdist
worker. (Opus 5.5 Review blocking finding.)
@RohanK6

RohanK6 commented Oct 23, 2026

Copy link
Copy Markdown
Contributor Author

Superseded by #23569: the same change as one commit on current main. It includes the fix for the fixed-sleep barrier that SAST and GPT flagged in the Weixin cancel test, which would have been a third commit here. The server.py:1450 finding comes from main's #23010 and isn't in this PR's diff; with #23010 in the new base it falls outside the review range.

@RohanK6 RohanK6 closed this Oct 23, 2026
@bolichen97
bolichen97 deleted the env-hotreload-22450-v3 branch November 6, 2026 07:18
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

readiness: action required A blocking check or review needs attention

Projects

None yet

Development

Successfully merging this pull request may close these issues.

.env changes require a full gateway restart (no hot-reload)

1 participant