Skip to content

feat: add Kiro Cloud Sessions as a session environment - #25347

Merged
bolichen97 merged 2 commits into
mainfrom
feat/session-environments-kiro-cloud
Nov 5, 2026
Merged

bolichen97 merged 2 commits into
mainfrom
feat/session-environments-kiro-cloud

Conversation

@kyleseaman

@kyleseaman kyleseaman commented Oct 28, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: Let a chat run entirely in a Kiro Cloud Sessions sandbox, chosen from the same Session Environments chip as a Coder workspace, without Kiro Crew building, reaching into or deleting that sandbox.

Kiro Agent's feature. Kiro Cloud Sessions is a feature of Kiro Agent, and this PR reaches it only through Kiro Agent over ACP: the _meta.kiro keys kiro-cli's --cloud sends on session/new and session/load, Kiro Agent's own Kiro sign-in, and Kiro Agent's _kiro/session/delete. Kiro Crew calls no cloud API of its own.

Today a Session Environments profile can only place a chat's tools in a Coder workspace the user runs themselves. A user with Kiro Cloud Sessions cannot start a Kiro Crew chat there: kiro-cli has a --cloud flag, but Kiro Crew's Kiro Agent sessions always run on the gateway.

Why it matters

Kiro Cloud Sessions gives a sandbox with no infrastructure to run, and keeps the agent working while the user's machine is off. Offering it as one more profile lets a Kiro Crew chat use it with the same picker, defaults and governance as any other environment.

Not a goal

  • Reaching the sandbox from Kiro Crew: its files, git and terminal are reached only by its own agent, so the Files view, health card and terminal refuse a cloud chat instead of serving the wrong machine.
  • Incognito and temporary chats: they can't use Kiro Cloud Sessions (below).
  • Deleting cloud sandboxes from any Kiro Crew cleanup (the known limit below).
  • Live verification against a real Kiro Cloud Sessions account (not done; see Manual verification).

Developer flag, off by default. Kiro Cloud Sessions, like every Session Environments provider, is reachable only with the developer flag KIROCREW_DEV_MODE set; it is off by default. With it off no Kiro Cloud Sessions profile is offered, a recorded cloud choice resolves to a local session, and a start never reaches the cloud path (test/test_kiro_cloud_session.py::test_a_cloud_choice_is_unreachable_with_the_developer_flag_off). No live run against a real Kiro Cloud Sessions account has been done yet; every test here runs against a local Kiro Agent stub.

What changed (motivation → approach → change)

Moved out of #21256. This is the Kiro Cloud Sessions half of #21256, split out so each PR reviews and lands on its own. #21260 built it and it rode on #21256 as that PR's second commit. This PR's tree is exactly that content rebased onto main, plus fix A below; #21256 is now credentialed git only. Its review history stays on #21256 and #21260.

Named Kiro Cloud Sessions everywhere a person reads it. The feature carries Kiro Agent's own name, plural and untranslated in all 12 languages: the Settings profile list and its Add and Remove buttons, the sandbox notices, the Files view, the incognito, governance and entitlement refusals, the config label (Kiro Cloud Sessions Profiles), the docs and the feature-map rows. Code identifiers, config keys (kiro_cloud_profiles), the kiro_cloud provider id, the notice kinds and stored values are unchanged.

On main. #21256 has merged, so this PR targets main and carries only its own two commits: the Kiro Cloud Sessions commit and the fix commit below.

Joins the provider registry Sprites and boxd added (#21257). Main now lists every provider once in config/session_environments.PROVIDERS, and Kiro Cloud Sessions is a row there (kiro_cloud, kiro_cloud_profiles, "Kiro Cloud Sessions"), but not in VM_PROVIDERS: Kiro Crew owns no VM and keeps no registry for it. So the cross-provider id rule, routing.profile_provider / chosen_provider, the choice row's CHOICE_PROVIDERS and the config writer's id-collision check cover it with no code of its own. Its list validates and loads through main's _validate_list / _load_list; a whole-section save keeps an omitted list through the same _keep_saved_profiles validator as Sprites and boxd; the explicit default leaf and a whole-section save go through main's write-time default check. prepare_for_session checks for Kiro Cloud Sessions before prepare_vm_session, and browse refuses it before the VM branch. The duplicate resolvers this PR carried in coder/session_launch.py are gone; it imports main's. In Settings, Kiro Cloud Sessions is the fourth provider choice beside Coder, Fly.io Sprites and boxd, inside main's numbered steps.

A Session Environments profile can say "run this whole chat in Kiro's cloud". Kiro Crew does not build a sandbox. It asks Kiro Agent for one with the same _meta.kiro keys kiro-cli's --cloud flag sends, confirmed against the installed kiro-cli 2.21.1's ACP client (newSession / loadSession). It refuses to start, rather than run locally, when Kiro Agent does not offer a cloud-sandbox target.

Part What it does
src/kiro_crew/config, config-baseline.json, src/kiro_crew/dashboard (handlers/core.py) session_environments.kiro_cloud_profiles: at most 20 {id, name, repositories} records, each with at most 10 owner/name repositories. A save that gives one id to both a Coder and a Kiro Cloud Sessions profile is refused with 400 profile_id_collision, writing nothing
src/kiro_crew/platform (governance_parts/catalog.py), src/kiro_crew/coder (session_launch.py), src/kiro_crew/session_allocation_parts (get_or_create.py) capabilities.kiro_cloud_sessions, opt-in. When the policy or the session's profile sets ANY other scope, a cloud start needs that row enabled in the POLICY; a profile can withdraw it, never grant it. The profile is the one the session's tool calls get: app-bound first (the chat slot's own app, which session allocation sets on the provider as owning_app; never transcript metadata), then agent, then surface. An unreadable ceiling refuses. Every decision writes a SEL governance event
src/kiro_crew/coder (session_launch.py, session_browse.py) the choice row records its provider; prepare_for_session returns PreparedCloudSession; the cloud id is recorded only if the same provider and profile are still chosen, else the start fails and the runtime is killed. Browse raises CloudSandboxOnly before any Coder call
src/kiro_crew/acp (harness/kas_cloud.py, harness/base.py, runtime.py, session_handle.py, session_handle_turn.py, session_handle_lifecycle.py, session_handle_runtime_contract.py, session_provider.py), src/kiro_crew/providers (acp_runtime_start.py, acp.py, base.py), src/kiro_crew/session_lifecycle_parts (fleet.py) KasCloudSandboxHarness sends executionTarget: cloud-sandbox plus the repositories (or isEmptyWorkspace), no MCP servers and no custom agent; every other host's request is unchanged (session_request seam, harness-parity H13). Replayed approvals are held by a resume hold only the provider's cloud start takes (hold_cloud_resume; the runtime's load_session is unchanged), plus two reader seams (holds_replayed_permission, unroutable_permission) every other host answers as a no-op, so the runtime's shared start and resume paths never test for the cloud harness. The cloud-only branches are the cloud harness itself, the provider's cloud start, and the handle's drain and teardown, which read is_cloud_sandbox. The keep-running rules below
src/kiro_crew/dashboard (chat_runner.py, chat_turn/turn_spec_hooks.py, handlers/session_environments.py), src/kiro_crew/context_assembly (turn.py) a failed reopen leaves a transcript error row (meta.kind = cloud_session_replayed); the environment endpoint returns the recorded provider; browse and file routes answer 409 cloud_sandbox; the [PROJECT] line names the sandbox
website/src/pages, website/src/components, website/src/api, website/src/app-sdk, website/src/i18n Kiro Cloud Sessions as the fourth provider choice on the Settings card: step 1 shows what opting in gives up, its setup steps and its profiles with their own buttons; step 2 says cloud profiles aren't checked ahead of time (no Check button); step 3 says sandboxes are listed in Kiro Web, not here; the chip names a cloud profile by its repositories, or "Empty workspace" when it has none; the Files panel shows the same info notice for a recorded cloud chat (sending no request) while a browse the gateway refuses with 409 cloud_sandbox is a rejected request and renders as an ErrorNotice with Ask the agent (no tree, Refresh or terminal), like any other listing failure; the error card renders cloud_session_replayed and cloud_session_replaced in the reader's language. Strings in all 12 catalogs
src/kiro_crew/change_card_catalog_kinds.py, docs kiro_cloud_profiles and default_profile are code-exec. Specs: providers.md, acp-client.md, session.md, config.md, governance.md, docs/feature-map/README.md

Governance is re-checked on every turn. The start's governance check is not enough on its own: a policy refresh or a profile edit can withdraw capabilities.kiro_cloud_sessions, or govern a new scope, while a cloud chat runs. So acp_turns._ready_confirmed_session, the gate every prompt, command and compaction send goes through, re-runs kiro_cloud_governance_refusal with the start's own (session_key, agent, app) for a cloud runtime. On a refusal it stops the cloud runtime (the sandbox is never deleted) and refuses the turn with words a retry can't change; the next start meets the same refusal. Other sessions skip it.

Incognito and temporary chats can't use Kiro Cloud Sessions. Such a chat never reopens its session (resume is for persistent chats only), so after an idle eviction or restart a cloud start would mint a new sandbox and silently strand the earlier one's files. It is refused before any sandbox exists, at three points: the start (_start_kiro_runtime_impl refuses a PreparedCloudSession for a non-persistent chat), the chat's environment choice (PUT …/environment answers 400 choice_refused, reason: private_chat, shown as "Kiro Cloud Sessions aren't available in incognito or temporary chats."), and a Kiro Cloud Sessions default (apply_default_environment leaves the chat on this machine). Coder and other remotes stay choosable. Pinned by test_a_private_chat_never_starts_a_cloud_sandbox, test_a_private_chat_cannot_choose_a_cloud_profile and test_a_private_chat_skips_a_kiro_cloud_default, each failing when its site is reverted, and a chip test for the message.

Cloud session lifecycle

The cloud agent keeps running when Kiro Crew lets go of it, so Kiro Crew never cancels or deletes it on its own:

When What happens
Gateway stops (graceful or not) The local Kiro Agent relay ends. A cloud turn is not cancelled: the shutdown drain and provider shutdown skip any provider whose turn_survives_disconnect is true. A user's Stop still cancels
Chat reopens session/load with the recorded id and sessionSource: remote; no second sandbox
An approval was pending Kiro Agent replays it during the load. It is held (60 s at most) until the session registers, then reaches the chat's normal approval path on the next turn; past that it takes the audited reject path
A new sandbox can't be recorded The start fails and deletes that sandbox first: it holds no conversation and nothing else points at it
A session/new no handle was returned for Deleted, because nothing records its id: a start whose local setup refuses (permission routing, mode, snapshot) after session/new answered, a late session/new answer nobody adopts, and the entitlement probe's own session. A session/load never counts, so a failed reopen keeps its session
Chat ends An ordinary chat unregisters locally and leaves the cloud session in place. No teardown deletes: a provider shutdown also runs on idle eviction, compaction, resets and gateway restarts, so a delete there would destroy a sandbox the chat still uses (incognito and temporary chats never reach the cloud at all). Deleting or archiving any chat keeps its cloud session too: the session is the user's own record in Kiro (listed in Kiro Web and the IDE), it may hold uncommitted work that exists nowhere else, and _kiro/session/delete cannot be undone, so removing a Kiro Crew row is not taken as consent to destroy it. Sessions Kiro Crew no longer points at are listed and deleted in Kiro Web (app.kiro.dev) or the IDE's cloud-session menu (Delete Session), per Kiro's docs
Reopen fails, or replays no earlier turn A new sandbox starts with the conversation carried over; the old session is left in Kiro's cloud, where it may still hold work. A load that replays no turn counts as failed (main's require_replay for Kiro Agent, unchanged). The transcript error says: "Couldn't reopen the cloud session, so a new cloud session started with this conversation carried over. Files and changes from the earlier session aren't in it. The earlier session wasn't deleted and is still listed in Kiro Web (app.kiro.dev)."
Edit & Resend, a reset or compaction Each drops the session's resume id, so the next start opens a new sandbox with no reopen attempted. The start compares the cloud id the chat's choice row held with the new one (record_cloud_session returns the earlier id, read under the write's lock) and, when they differ, leaves an error row (meta.kind = cloud_session_replaced): "This chat now runs on a new Kiro Cloud Sessions sandbox. Files and changes from the earlier sandbox aren't in it. The earlier sandbox wasn't deleted and is still listed in Kiro Web (app.kiro.dev)." A reopen of the same id or a first start leaves none
Subagent continued after its parent's row aged out It keeps its own placement: the Kiro Cloud Sessions profile, provider and recorded cloud session, so it reopens its sandbox instead of being re-recorded as Coder.

A chat's environment locks only once Kiro's cloud holds the session; a start refused before then leaves the chat free to move back to this machine. Riders: default_profile moves from cannot-widen to code-exec, because a default can now bind every new chat to a sandbox outside the tool gate; Kiro Cloud Sessions joins the i18n glossary.

Known limit: no cleanup deletes a sandbox. Kiro Crew never deletes a cloud session from a chat's teardown, archive or delete, because a provider shutdown also runs on idle eviction, compaction, resets and gateway restarts. The only sessions it deletes are ones no handle was ever returned for (see the table). Sessions Kiro Crew no longer points at stay in Kiro's cloud until the user deletes them in Kiro Web or the IDE.

Terminal reconnect fix (fix A). Opening a terminal on a Kiro Cloud Sessions chat raised CloudSandboxOnly, a subclass of SessionEnvironmentUnavailable, so terminal_placement._remote_terminal_argv answered terminal_placement_unavailable and the tab showed "reconnecting" and redialled about 10 times before giving up. It now catches CloudSandboxOnly first and answers terminal_wrong_machine, so the tab parks at once, as for any chat whose shell runs elsewhere. Pinned by the cloud case in test_session_environment_handlers.py::test_terminal_remote_slot_never_falls_back_to_a_local_shell, which fails with the arm removed.

Earlier review rounds, carried here:

  • On B's latest head, the locked environment chip follows the profile the chat is BOUND to; a Kiro Cloud Sessions chat's bound profile still gets the plain status with no health card.
  • Onto main through the stack (A and B now on main): main split change_card_catalog.py, so the two settings-list edits sit in change_card_catalog_kinds.py; B's new class test now expects session_environments.default_profile under _CODE_EXEC_SETTINGS, where the Kiro Cloud Sessions commit puts it; main renamed the Kiro Agent backend's label to "Kiro Agent", so the glossary drops kiro-agent and the setup-step test reads the new label.
  • The runtime split (acp/runtime.py into its runtime_* owners): the cloud hooks moved to their owners (set_cloud_sandbox/hold_cloud_resume in runtime_remote_workspace.py, is_cloud_sandbox and _unclaimed_new_sessions on the class, the request shaping in runtime_session_create.py/runtime_session_load.py, teardown in runtime_session_registry.py, the replay hold in runtime_reader_loop.py/runtime_host_requests.py), with the binding ratchet updated. The core.py and chat_runner.py splits likewise: the editable-config entry is in core_config_schema.py, the id-collision check in core_config_patch.py, the startup notice in chat_turn/turn_admission.py.
  • B's fail-closed choice store (bound markers, before sets, refusing an unreadable row) now also records and checks the provider: an unknown provider is refused, not read as local.
  • B's developer flag now gates Kiro Cloud Sessions as well as Coder (above), and health's placement table forgets a cloud runtime's entry when it ends, as it does for a Coder relay.
  • The Files panel's root listing uses health's per-folder query key, so it and the tree share one request again.
  • Coder profiles still have no leaf path (B); session_environments.kiro_cloud_profiles keeps the leaf path feat: run a chat in a Kiro Cloud Sessions sandbox #21260 gave it.
  • Renaming a Kiro Cloud Sessions profile's id carries the default along, as a Coder rename already did (a dangling default is refused on save), and a Coder id passing through empty no longer takes a cloud default. Removing the default profile moves it to another profile of the same provider first (a cloud default is no longer moved to a Coder workspace while a cloud profile is left), and the "default was removed" notice reads both lists.
  • A start that ends after session/new answered but before its handle is returned (the chat closed mid-setup, or a setup step with no refusal arm of its own failing) tears the minted session down, so a cloud sandbox is deleted rather than left untracked. create_session guards the whole post-session/new setup; the guard skips an id an inner arm already freed, and is shielded against a second cancel.
  • Health's environment health card does not apply to a cloud sandbox: the fixed chip on a Kiro Cloud Sessions chat is a plain status with no health card, and the health route answers 409 cloud_sandbox for a cloud chat, as the browse routes do (it used to open a card that retried a 502).
  • Kiro Cloud Sessions' two unpushed copy fixes are folded in: "a new cloud session started" in the reopen notice, and the repositories hint naming the source provider connected to the Kiro account.
  • A save from an older card cannot wipe Kiro Cloud Sessions profiles. A whole-section session_environments save keeps every optional key it omits through that key's own loader validator (a hand-edited value the loader refuses is not carried, and a key with no validator is never carried; a test pins one validator per key). Profile lists merge before the default, so a default naming a kept Kiro Cloud Sessions profile survives a save from a tab that predates Kiro Cloud Sessions. Revert-fail: TestStaleCardSave fails against the previous merge rule.

Backwards compatibility

Compatible: kiro_cloud_profiles is a new optional key, empty by default, so every existing profile, chat and save behaves as before. Every new runtime branch (no drain cancel, held approvals, local-only teardown, the startup notice) is keyed on the cloud harness, so other hosts keep their wire and teardown. One change-card classification moves: editing session_environments.default_profile shows the code-exec card; the values it accepts are unchanged.

One write rule differs from Sprites and boxd, as this PR already had it: a kiro_cloud_profiles leaf write that removes the default's profile is accepted and drops the default (_drop_dangling_default_profile), where a sprites_profiles or boxd_profiles leaf write that would is refused. The rule is unchanged for each list.

Readers that now meet a kiro_cloud choice row, unchanged by this PR, each staying closed:

  • Reader: session_environment.session_runs_remotely answers True, so local-only tools stay refused for a cloud chat, as for a Coder one.
  • Reader: coder/retention.py:warn_unsaved_work asks session_browse.unsaved_work, whose _resolve raises CloudSandboxOnly; the check logs it and the archive goes on with no notice.
  • Reader: providers/acp_lifecycle.py:_bound_remotely answers True, so a non-runtime backend refuses with REMOTE_NEEDS_KAS instead of starting locally.
  • Reader: the setting.change card for session_environments.default_profile now asks for code-exec approval.

Removes nothing: no key, route, tool or setting goes away, and the session_request seam returns its inputs unchanged for every existing host, and the two reader seams do nothing on them.

Tests

  • website/src/i18n/kiroCloudSessionsName.test.ts (new): every catalog names the feature exactly "Kiro Cloud Sessions" (a shortened "Kiro Cloud", a singular or a hyphenated compound fails), and the Settings heading and profile buttons keep the full name; it fails with the old "Add Kiro Cloud profile" restored. SessionEnvironmentsCard.test.tsx also asserts the rendered tab shows no shortened name.
  • test/test_kiro_cloud_session.py (new, 104 tests against a Kiro Agent stub): the session/new / session/load shapes, the empty workspace, and the refusal when Kiro Agent offers no cloud-sandbox. Governance: a ceiling on any scope refuses until the policy opts in; a profile cannot grant; an unreadable ceiling refuses; every decision is audited. Lock: a refused start can move back; a cleared, Coder or other-cloud choice during the reply fails the start and kills the runtime. Keep-running: the drain and close_all send no cancel or delete for a cloud turn while an ordinary Kiro Agent turn still cancels; the next start reloads the same id; a replayed approval reaches the normal approval event, also with a stranded request queued behind it, and an unregistered one expires; every served host answers the reader seams as a no-op, the shared destroy and turn drain carry no getattr probe for is_cloud_sandbox, the runtime's load_session takes no hold, and the provider's cloud start does; no chat teardown deletes, in any memory mode; a refused cloud start, an unadopted late session/new and the entitlement probe delete the session they minted; a failed reload after a successful load deletes nothing; the fallback notice is logged and surfaces once, including through a real dashboard turn (test/turn_harness.py's run_turn; removing the call in _run_chat fails it).
  • test/test_session_environments_config.py, test/test_change_card_setting_classes.py, test/test_session_environments_start_gate.py: round-trip and collision refusal, default_profile is code-exec, a cloud-only config counts as configured. test/test_acp_bindings.py, test/test_acp_harness_contract.py, test/test_acp_runtime_load_session.py, test/test_harness_parity.py follow the new property and the moved _load_session body.
  • Frontend: website/src/test/SessionEnvironmentsCard.test.tsx (the cloud section sits outside Coder's steps, with its own labels and plain-view cost), website/src/test/RemoteFilesPanel.test.tsx (a recorded cloud placement renders an info notice with no browse call; a 409 cloud_sandbox browse is an alert with Ask the agent and no Refresh, tree or terminal, and a real listing failure stays an alert with Ask the agent), website/src/test/SessionEnvironmentChip.test.tsx, website/src/test/ErrorCard.test.tsx (the replay error is localized), website/src/test/settingsCoverage.test.ts.
  • Not run here: the full CI suites (CI runs them), native Windows and macOS, guest Python 3.9, and live provider infrastructure. No real Kiro Agent sign-in with Kiro Cloud Sessions was used: Kiro Agent is a stub, so whether the cloud keeps the turn across the relay's SIGTERM is taken from Kiro's docs, not measured.
  • test/test_session_environment_handlers.py: a Kiro Cloud Sessions chat's terminal gets terminal_wrong_machine (fix A).
  • test/test_kiro_cloud_sandbox_notice.py (new): Edit & Resend, a reset and compaction, each through SessionManager's own call (discard_conversation, discard_conversation(replay=False), reset(clear_conversation=True)), clear the resume id, and the next start reports cloud_session_replaced and deletes nothing; a reopen of the recorded id and a first start report nothing; a load that replays no turn falls back with the failed-reopen notice. Each fails with the notice code reverted. The Kiro Agent stub now replays one turn on a load (as Kiro Agent does), unless told not to.
  • test/test_kiro_cloud_turn_governance.py (new): governance is re-checked on every turn of a running cloud chat, not only at its start. A narrowed ceiling refuses the next turn (fixed-remedy AcpError, no session/prompt, no _kiro/session/delete, runtime stopped); a chat the ceiling still allows keeps working and is re-checked once per turn with its start's own (session_key, agent, app); local and remote-workspace runtimes are never checked. The first two fail with the admission call removed, the last with its cloud-runtime guard removed.
  • Settings: the Session Environments card is now a lazy chunk (React.lazy in SettingsPage.tsx, behind a Suspense skeleton), since it mounts only behind its preview. Built locally with vite build --mode analyze: SettingsPage is 480,683 B (under the 500 KB default) and the card is its own 37,342 B chunk; the bundle-size gate passes with no CHUNK_BUDGETS change. SettingsPage.test.tsx waits for the lazy card.
  • Inherited from main, not this PR: test_mate_conductor_agent.py and test_agent_refactor_spec_bytes.py (12 tests) failed on main too and are fixed by test(crew): read the crewmate conductor as ledger-mounted #28301, now merged; this head includes it.
  • test/test_kas_mcp_live_reinject.py: a cloud session ignores the MCP re-injection mark and never reloads, while the writer still skips the reset for it.
  • Ran by the agent on 53a84922a7 (the head after it, bdb4eebcd7, only reshapes one return so mypy can narrow it; mypy 1.14.1 at CI's pin flagged the old line and passes the new one) (scoped, low worker count): 24 backend files with pytest -n 4 (1,560 passed; the one local failure, test_runtime_bindings.py::test_the_constructor_keeps_its_type_hints, is a Python 3.13 pathlib._local.Path repr that CI's 3.12 does not produce), then the four real failures it found (three test-only, one test pin on the provider list) fixed and re-run green; tsc (run before a last two-line card change that eslint then covered); vitest on the Session Environments card, chip, ErrorCard, RemoteFilesPanel, settings coverage and src/i18n/ (2 workers; its two failures, a Hindi register rule and a test's section name, fixed and re-run green); i18n:check; gen:settings, gen:ui, i18n:pseudo and the config baseline (no drift); black, flake8, isort, eslint, the line-cap check. Revert check: with the cloud_session_replaced branch disabled, the four replacement tests in test_kiro_cloud_sandbox_notice.py fail.

Manual verification

Not verified against a real cloud account. Whether a cloud turn actually keeps running after the local Kiro Agent relay stops has not been tested against a real Kiro Cloud Sessions account. Every test here ran against local Kiro Agent stubs; the keep-running behaviour above is what Kiro Crew sends and stops sending, and the claim that the cloud keeps the turn comes from Kiro's docs.

Kiro Agent limits, as found:

Limit Value Source
Concurrent cloud sessions 10 Kiro's Cloud sessions page
Region us-east-1 only same page
Attach-stream re-attach budget 60 s (backoff 250 ms to 10 s) constant in Kiro Agent's client code
Provisioning deadline 25 min constant in Kiro Agent's client code
Idle timeout not documented, not measured none
Maximum lifetime not documented, not measured none
  • Rendered the Settings card, chip picker, Files panel and transcript error row from this head with stubbed API answers (below).
  • Still to do: one live cloud session through a Kiro Agent sign-in that offers cloud-sandbox, including a gateway restart mid-turn, a reopen with a pending approval and a session/load resume.

Screenshots / video

After the rename, on this head. The Kiro Cloud Sessions provider tab, opened on a setup with only Kiro Cloud Sessions profiles saved: setup steps (step 1 names the Kiro Agent backend), the plain-view warning, the Kiro Cloud Sessions profiles list with a profile expanded, its Remove Kiro Cloud Sessions profile and Add Kiro Cloud Sessions profile buttons, step 2 saying these profiles aren't checked ahead of time, and step 3 saying each chat's Kiro Cloud Sessions sandbox is listed in Kiro Web. The capture script fails if any shortened "Kiro Cloud" is on the page.

Kiro Cloud Sessions provider tab after the rename, dark

Light theme

Kiro Cloud Sessions provider tab after the rename, light

Earlier captures (the fixed chip, the Files panel and the transcript notices) were taken before the rename and showed the old name, so they are removed. Their behaviour is unchanged, and their wording is asserted in RemoteFilesPanel.test.tsx, ErrorCard.test.tsx and SessionEnvironmentChip.test.tsx.

Related Issues

Part of #10433

no linked issue: this PR closes nothing; #10433 stays open until the whole Session Environments stack lands.

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)
  • No secrets, credentials, or internal references in the diff

Contribution License Agreement

Contributed under the project's Apache-2.0 license (see the Licensing section of CONTRIBUTING.md).

@kyleseaman
kyleseaman requested review from a team and KiroCrewCaptain as code owners October 28, 2026 17:37
@kyleseaman
kyleseaman requested review from dodgeblaster and removed request for a team October 28, 2026 17:37
@github-actions github-actions Bot added the readiness: checking Automated validation is still running label Oct 28, 2026
@github-actions

github-actions Bot commented Oct 28, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Opus 5.5) — ✅ PASS

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

Design-Verdict: PASS

Nothing blocks: the cloud path is a per-runtime harness subclass behind the developer flag and a policy opt-in, and other hosts are untouched.

Notes

  • A cloud chat's tools run in the sandbox and never pass Kiro Crew's PreToolUse gate. Right now capabilities.kiro_cloud_sessions and the developer flag are the only things holding that line. Before the flag goes away, say plainly in the governance spec that turning the row on means giving up per-tool governance for that chat.
  • The description is cut off before ## Backwards compatibility, so I didn't check the reader list against it. The only take-away I found, terminate_session gaining a defaulted keyword-only argument, breaks no reader.

[DESIGN-REVIEWED] f058a27

Description read

[DESCRIPTION-READ] 0080d7cb1f58bd924e49c3049feb48b2f2b4b1081f4b1c5677c6d01e677c3842

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 28, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Opus 5.5) — ✅ PASS

Premise-level review of f058a27e0f0daaf742ee28b0a992d82b5b317622 — 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: the whole feature sits behind KIROCREW_DEV_MODE, which is off by default, and every other harness gets the default answer from the new harness seams. Two notes on unverified premises.

Notes

  • Item 3 — inherited: the wire contract rests on "confirmed against the installed kiro-cli 2.21.1's ACP client" and "No live run against a real Kiro Cloud Sessions account has been done yet". This is not a block because only flag-on cloud starts depend on it. Local starts get the request unchanged.
  • Item 5 — one consumer, generalized: holds_replayed_permission and unroutable_permission on HarnessAdapter have exactly one host that overrides them (KasCloudSandboxHarness, 1 of 1 overrides grepped in acp/harness/). H13's seam rule supports this shape. It is the first thing to delete if the cloud harness is withdrawn.

What this change ships

Inventory (10 items) — 8 justified

Intent: let a chat run entirely in a Kiro Cloud Sessions sandbox, picked from the Session Environments chip — ADDITION (behind the developer flag)

  1. Settings has a fourth provider, Kiro Cloud Sessions, with its own profile list (kiro_cloud_profiles, capped at 20 profiles) — justified
  2. A save that gives one id to two profiles is refused with 409 profile_id_collision — justified
  3. A chat whose profile is a cloud one starts in a cloud sandbox through _meta.kiro executionTarget — inherited, not verified live
  4. New policy row capabilities.kiro_cloud_sessions, opt-in, checked at start and again on every turn — justified
  5. Approvals that Kiro Agent replays while a cloud session reloads are held until the session is registered — one consumer, generalized
  6. Teardown and MCP re-inject only detach a cloud session and never delete its sandbox — justified
  7. Notices in the transcript when a reopen fails or a resend replaces the sandbox — justified
  8. The Files view, browse and terminal refuse a cloud chat (409 cloud_sandbox) — justified
  9. The Session Environments card loads lazily in Settings (bundle budget) — justified
  10. The feature is named "Kiro Cloud Sessions" in all 12 locales, with a catalog test that pins the name — justified

[FIRST-PRINCIPLES-REVIEWED] f058a27

Description read

[DESCRIPTION-READ] 75a32aea3498d774f674c3ca6dbe9f27ba8b14a8ff065eb0128cd83f6799b991

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 28, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Opus 5.5) — ✅ PASS (a BLOCK with no Trigger and no Outcome does not block)

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

UX-Verdict: PASS

cannot evaluate: missing the chat-side surfaces this PR adds. Both screenshots show only the Settings card. No screenshot shows the environment picker row, the locked cloud chip, the Files view notices, the replayed/replaced transcript cards or the incognito refusal.

Evidence gaps

  • "Run this chat on" picker row for a Kiro Cloud profile: the row shows its repositories or "Empty workspace" (SessionEnvironmentChip.tsx). This is the main control the PR exists for. Close with a screenshot of the menu open next to the message box with a cloud profile listed.
  • Locked chip on a cloud chat, which has no health card (cloudSandbox branch in SessionEnvironmentChip.tsx). Close with a screenshot of the chip after the first message.
  • Files view notices: remoteFiles.cloudSandbox (info) and remoteFiles.cloudSandboxRefused (error with the ask-agent hand-off) in RemoteFilesPanel.tsx. Close with a screenshot of each.
  • Transcript notices: kiroCloud.replayed and kiroCloud.replaced as rendered by ErrorCard.tsx. Close with a screenshot of each.
  • Incognito/temporary refusal: picker.privateChat. Close with a screenshot of the picker refusing in an incognito chat.

Notes

  • managementHintKiroCloud hides key information. Archiving or deleting a chat leaves a sandbox the user must clean up in Kiro Web, and that fact sits at the end of muted prose. The blind reader said: "I worry about leftover sandboxes I'd have to clean up somewhere else." Move it into the limits warning.
  • "Stop workspaces when Kiro Crew shuts down" still shows on the Kiro Cloud panel, and its helper text mentions Coder. The blind reader could not tell whether the toggle affects cloud chats. Hide the toggle for kiro_cloud, or say it doesn't apply.
  • kiroCloud.profilesHint says "session" and "environment menu beside the message box", while managementHintKiroCloud says "chat" and "'Run this chat on' menu next to the message box". The reader couldn't tell whether these name the same things. Use "chat" and "'Run this chat on' menu" in both.

[UX-REVIEWED] f058a27

Description read

[DESCRIPTION-READ] 05a4246ae6b2bebc8a70994ca4dd8131366a8ca157b86a108c7cb34aa4855f31

That sha256 names everything this verdict read: the PR description, plus the 5 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 added merge conflict Branch has merge conflicts with its base — author must resolve before merge readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Oct 28, 2026
@kyleseaman
kyleseaman force-pushed the feat/session-environments-kiro-cloud branch from 4596e8f to 4e2c13f Compare October 28, 2026 18:52
@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 Oct 28, 2026
@kyleseaman
kyleseaman force-pushed the feat/session-environments-git branch from df8c46c to 77f1592 Compare October 28, 2026 18:58
@github-actions

github-actions Bot commented Oct 28, 2026 •

Copy link
Copy Markdown
Contributor

GPT 6.1 Review — ✅ no blocking findings

GPT 6.1 completed its review of f058a27e0f0daaf742ee28b0a992d82b5b317622 and found no blocking issues.

This comment is updated in place on each push.

Review details

No findings.
[GPT-REVIEWED] f058a27

False positive or not applicable? A repository writer can comment:
/ai-review override gpt f058a27e0f0daaf742ee28b0a992d82b5b317622 false-positive: <reason, 20 to 500 characters>

@github-actions

github-actions Bot commented Oct 28, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5.5 Review — ✅ no blocking findings

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

Review details

No findings.

[OPUS-REVIEWED] f058a27

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

False positive or not applicable? A repository writer can comment:
/ai-review override fable f058a27e0f0daaf742ee28b0a992d82b5b317622 false-positive: <reason, 20 to 500 characters>

@kyleseaman
kyleseaman force-pushed the feat/session-environments-kiro-cloud branch from 4e2c13f to e0e28ad Compare October 28, 2026 19:19
@kyleseaman

Copy link
Copy Markdown
Contributor Author

Re GPT 6.1 Review BLOCKING at src/kiro_crew/acp/runtime_remote_workspace.py:193 (local MCP edits auto-reject pending cloud approvals): fixed in 2012f94. A Kiro Cloud session sends no MCP servers, so mark_mcp_config_changed and apply_pending_mcp_reinjection in src/kiro_crew/acp/session_provider_mcp_reinject.py are now no-ops on a cloud-sandbox runtime: no evict/re-load happens outside hold_cloud_resume, and replayed approvals stay routed. The writer still skips the reset for it (mcp_config_wire_reinject unchanged), so a cloud session neither forces a reset of other sessions nor gets reset itself. Tests: TestACloudSession in test/test_kas_mcp_live_reinject.py (3 tests, all fail without the fix).

@github-actions github-actions Bot removed the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Oct 28, 2026
@kyleseaman
kyleseaman force-pushed the feat/session-environments-git branch from 77f1592 to 989a798 Compare October 28, 2026 20:04
@github-actions github-actions Bot added merge conflict Branch has merge conflicts with its base — author must resolve before merge readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Oct 28, 2026
@kyleseaman
kyleseaman force-pushed the feat/session-environments-git branch 2 times, most recently from 3e4befd to 1cb9be4 Compare October 29, 2026 00:01
Base automatically changed from feat/session-environments-git to main October 29, 2026 15:53
@kyleseaman
kyleseaman force-pushed the feat/session-environments-kiro-cloud branch from 2012f94 to 53a8492 Compare November 2, 2026 15:42
@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 Nov 2, 2026
@github-actions github-actions Bot added the readiness: passed Eligible automated validation passed for the current revision label Nov 3, 2026
@iamwhatever

Copy link
Copy Markdown
Contributor

HOLD (policy_sensitive) at 217633b.

This head restacks the PR onto main. Kiro Cloud Sessions now joins the shared provider registry, with no duplicate resolvers. All 99 check runs are success or skipped, and PR Readiness is green. GPT 6.1 and Opus 5.5 report no findings, and the earlier GPT and Opus blocks have fixes and replies. The feature stays behind KIROCREW_DEV_MODE, which is off by default. I found no concrete defect in what I read.

This PR stays reserved for a human reviewer. It adds a governance capability, capabilities.kiro_cloud_sessions (catalog.py). It lets a chat's agent and tools run in Kiro's cloud, outside every Crew gate. It also adds a per-turn re-check that stops a runtime when governance withdraws it (acp_turns.py, kiro_cloud_governance_refusal).

Still open from my r142 review:

  • The known limit "no cleanup deletes a sandbox" has no linked issue. Please open one that says who deletes the sandboxes Crew stops pointing at before the developer flag comes off, and link it in the description.
  • Design Review still names the lack of a live run against a real Kiro Cloud Sessions account. Every test runs against a local stub. A maintainer should decide whether a live run is needed before merge.
  • UX Review lists missing screenshots for the chat-side surfaces, and the old screenshots were removed after the rename. The feature is dev-flagged, so this does not block, but nobody has answered it.

— crew-pr-reviewer (r144)

@github-actions github-actions Bot added the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Nov 3, 2026
@kyleseaman
kyleseaman force-pushed the feat/session-environments-kiro-cloud branch from 217633b to e83a76b Compare November 4, 2026 03:59
@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: passed Eligible automated validation passed for the current revision merge conflict Branch has merge conflicts with its base — author must resolve before merge readiness: checking Automated validation is still running labels Nov 4, 2026
@kyleseaman
kyleseaman force-pushed the feat/session-environments-kiro-cloud branch from e83a76b to fdc7863 Compare November 4, 2026 06:23
@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 Nov 4, 2026
@kyleseaman

Copy link
Copy Markdown
Contributor Author

Opus 5.5 BLOCKING (src/kiro_crew/coder/session_browse.py:115, deleted cloud profile falls back to Coder): fixed in fdb45e7.

  • _resolve now raises CloudSandboxOnly as soon as the choice row records kiro_cloud, before any config, chosen_provider or Coder/VM resolution. The kind == kiro_cloud branch is kept.
  • New test test/test_session_environment_handlers.py::test_a_cloud_chat_stays_a_cloud_sandbox_once_its_profile_is_gone (profile deleted, id reused by a Coder profile, id reused by a Sprites profile): browse and health answer 409 cloud_sandbox and the terminal gets terminal_wrong_machine, with no Coder or VM call. All three cases fail without the fix.
  • Swept the other readers of a chat's environment: start/reopen (prepare_for_session), the choice lock (_fixed_by_provider) and the slot environment response already route on the recorded provider. Added test_a_cloud_chat_whose_profile_was_deleted_is_refused_not_started_on_coder to pin the start path.

@bolichen97 bolichen97 left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Reviewed head fdb45e7. CI is green (102 checks ok, none red or pending), the branch is mergeable, and the Design, First Principles, UX, Opus and GPT lanes all pass on this head.

Requested change

1. New regex for repository validation (config/session_environments.py)

The PR adds _REPOSITORY_RE and uses fullmatch to decide which repositories entries are accepted and later sent to Kiro Agent as the cloud checkout list. This project no longer takes new regex-based validation or parsing. Please replace it with a structured check, for example:

  • split the stripped value once on / into at most two parts (name or owner/name);
  • check each part's length bounds explicitly (1 to 100);
  • check characters with a fixed set (set(part) <= _REPO_CHARS) and require the first character of the owner part to be alphanumeric;
  • reject . and .. as a part, which the current pattern allows.

A small typed helper (for example parse_repository(value) -> tuple[str | None, str]) keeps the same error message and gives the tests something exact to assert on. Existing regex in this file is out of scope.

Design brief (needs a maintainer sign-off before merge)

  • What it does: adds Kiro Cloud Sessions as a session environment. A chat bound to a cloud profile runs its agent and tools in a Kiro cloud sandbox through Kiro Agent, with a new opt-in governance capability capabilities.kiro_cloud_sessions, a Settings card, chip rows, Files panel notices and transcript error rows. It sits behind the developer flag.
  • Pros: purely additive; other providers do not reach the cloud harness; private chats are refused; a governed host refuses the start unless the policy itself opts in, a profile can only withdraw it, and unreadable policy or profiles fail closed with an audit row.
  • Cons: tools in a cloud session never pass this host's PreToolUse gate, denied-command floor, steering or MCP servers. On a host with no governance policy that is allowed by default once a profile is chosen. A re-start that gets a new sandbox leaves the old sandbox behind and the user is not told (the Design lane note). The UX lane could not see the chip, Files panel and error row states.
  • Long-term tech debt: some. A second execution model that bypasses the local gate has to be kept in mind by every future gate change, and sandbox cleanup is left to the cloud side.

What I read

Every hunk of the cloud harness (acp/harness/kas_cloud.py), the config validation and section changes, the governance baseline, catalog and spec text, the launch seam (coder/session_launch.py, including kiro_cloud_governance_refusal and the cloud session record), and the startup notice surfacing. Not yet read line by line: providers/acp_runtime_start.py, providers/acp_turns.py, the acp/runtime_* changes, the dashboard handlers and the website components. I will finish those on the next head.

@kyleseaman

Copy link
Copy Markdown
Contributor Author

@bolichen97 Review 5765854196, requested change 1: _REPOSITORY_RE is replaced by the typed parse_repository(value) -> tuple[str | None, str] with _REPO_CHARS (split once on /, 1 to 100 per part, ./.. refused, first part alphanumeric, same error message) plus tests, in commit fc64796 (head a4b5233).

@bolichen97 bolichen97 left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Maintainer decision (security sign-off): accepted. Cloud sessions running tools outside the PreToolUse gate on hosts with no governance policy is accepted as written, on by default. The earlier regex point is fixed, and I found no new regex in product code.

Thank you for the quick fix at 9d74386: the lock file in swap_cloud_session now opens with owner_only_opener_for, which is what the owner-only creation check failed on at the previous head. CI on this head is still running (E2E and the render benchmark among others), so I am not approving yet. I will approve once it is green.

@bolichen97 bolichen97 left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Maintainer decision (security sign-off): the Kiro Cloud Sessions environment stays accepted as written, on by default. The rule is that we do not raise security strictness, so two small parts that make existing, non-cloud behavior stricter need to come out before I approve.

I read the whole diff at 9d74386. The lock-file fix is in, I found no new regex in product code, and the cloud-only gates (governance, private chats, and the Files and terminal refusals) only cover the new environment, so they stay. Please change these:

  1. change_card_catalog_kinds.py: session_environments.default_profile moves from _CANNOT_WIDEN_SETTINGS to _CODE_EXEC_SETTINGS. That raises the class of an existing setting for every host, including Coder, Sprites and boxd defaults. Please keep default_profile where it was on main. Adding the new kiro_cloud_profiles key to _CODE_EXEC_SETTINGS is fine.
  2. dashboard/handlers/session_environments.py, _fixed_by_provider: except SessionEnvironmentUnavailable: return True locks the environment choice of every chat, local ones included, when the choices file cannot be read. The route above it notes that an unreadable file must not lock a local chat. Please fall back to main's behavior there and lock only on positive cloud evidence.

One small fix, not blocking: in providers/acp_runtime_start.py, the cleanup call await runtime.terminate_session(handle.session_id, delete_cloud_session=True) inside except BaseException: is not shielded. A second cancel can interrupt it and leave a cloud sandbox with no recorded id. Wrapping it in asyncio.shield(...) matches the teardown in create_session.

Sensitive Change Review is red at this head, and Windows shard 2 and Coverage Combine are still running. Once these two parts are back to main's behavior and CI is green, I will approve. Thank you.

@kyleseaman

Copy link
Copy Markdown
Contributor Author

@bolichen97 Review 5777794841: all three are in commit 88198b5 (head e33f408): default_profile is back in _CANNOT_WIDEN_SETTINGS as on main (only kiro_cloud_profiles is code-exec), _fixed_by_provider locks only on positive cloud evidence, and the unrecorded-sandbox delete is shielded, each with a fail-first test.

@bolichen97 bolichen97 left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Maintainer decision (security sign-off): accepted, as before. Thank you: at e33f408 all three points from my last review are fixed. default_profile keeps main's class (and a test now pins it), _fixed_by_provider locks only on positive cloud evidence, and the cloud cleanup is shielded. The delta adds no regex.

One thing still blocks the approval: Backend Tests (3.12, 7) failed twice on this head, both times after about 19 minutes in "Run tests (shard 7/8)" with no failed test in the log, which looks like a hang or a timeout rather than an assertion. The other shards, the AI lanes and E2E pass. Could you check whether one of the new cloud tests can block in that shard? Once shard 7 is green I will approve.

@bolichen97

Copy link
Copy Markdown
Contributor

The Slack code-channel test failures on Windows shard 7 came from a regression on main, which is now fixed there. Could you update this branch onto main? That clears those failures, and it also re-runs Linux shard 7, the hang I asked about in my last review. Once both shards are green I will approve. Thank you.

kyleseaman and others added 2 commits November 5, 2026 04:02
A Kiro Cloud profile asks KAS to place the session in a Kiro cloud sandbox
with the _meta.kiro keys kiro-cli's --cloud flag sends, and refuses to start
rather than run locally when KAS does not offer cloud sandboxes.
…ends replace a session

A Kiro Cloud Sessions chat sends no MCP servers, so a local MCP edit has nothing to
re-send to it. Marking it anyway made its next turn evict and re-load it outside
the cloud start's resume hold, and the approvals Kiro Agent replays on that load were
rejected as unroutable instead of reaching the user's approval card. The mark and
the apply are now no-ops on a cloud-sandbox runtime; the writer still skips the
reset for it.

Edit & Resend, a reset and compaction drop a session's resume id, so the next
start reaches session/new and Kiro's cloud opens a new sandbox without the
earlier one's files, with nothing said. record_cloud_session now returns the id
the choice row held before (read under the write's lock); a start that replaced
it leaves a cloud_session_replaced notice: the chat runs on a new sandbox, and
the earlier one was not deleted and is still listed in Kiro Web. The failed-reopen
notice (also taken when a load replays no turn, require_replay) now says the
earlier session was not deleted too.

A running cloud chat is also judged by the governance ceiling on every turn,
not only at its start: a policy refresh or profile edit can withdraw
capabilities.kiro_cloud_sessions or govern a new scope while it runs, and its
tools run outside every gate Kiro Crew enforces. The start records its
(session_key, agent, app); each send re-runs kiro_cloud_governance_refusal for a
cloud runtime and, on a refusal, stops the runtime (never deleting the sandbox)
and refuses the turn with a fixed remedy. Other sessions skip it.

The Session Environments card is now a lazy chunk in Settings: it mounts only
behind its preview, and the Kiro Cloud Sessions tab had pushed SettingsPage past its
500 KB budget.

Everything a person reads names the feature Kiro Cloud Sessions, Kiro Agent's
own name for it, untranslated and plural in every catalog: the Settings
profile list and its buttons, the sandbox notices, the Files view, refusals,
the config label and the docs. A catalog test fails on a shortened
"Kiro Cloud". Code identifiers, config keys and stored values are unchanged.
@kyleseaman

Copy link
Copy Markdown
Contributor Author

@bolichen97 Rebased onto main (includes #30127, the Slack code-channel fix that was red here); no code change since your last review, now at f058a27.

@bolichen97 bolichen97 left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Maintainer decision (security sign-off): accepted. The Kiro Cloud Sessions environment, with cloud sessions running tools outside the PreToolUse gate on hosts with no governance policy, on by default, is approved under the rule that we do not raise security strictness.

Reviewed at f058a27. Every added and removed line is the same as the head I read in full (e33f408); only the base moved with the update onto main. At this head all 99 checks pass, with none red or pending, including both shard 7 runs. The two stricter parts are back to main's behavior, the cloud cleanup is shielded, there is no new regex in product code, and no other change request is open. This approval replaces my earlier change request. Thank you for working through every round on this one.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants