Repository navigation
Conversation
917cf6e to
8d163ca
Compare
|
CI is held pending workflow approval — could a maintainer approve the runs? This is a fork PR, so
Two notes so review isn't wasted:
I'll avoid further force-pushes unless you ask for changes — the earlier one reset |
8d163ca to
565acb3
Compare
20df833 to
f954cee
Compare
|
Rebased onto current Two structural conflicts came up while catching up to
The rebase also exercised the drift-guard test I shipped with this PR: All six gates that were red on the previous head are fixed and were green on that run; everything is re-verified locally on this head: This still needs a maintainer to "Approve and run workflows" — a fork PR's substantive lanes don't run until then, and each head-changing push resets that approval, so the green checks currently showing are only the fork pre-flight lanes. Once the real matrix runs I'll address anything it surfaces. Scoped strictly to #7577; marked |
f954cee to
de09080
Compare
223a692 to
96133cb
Compare
96133cb to
2544081
Compare
|
Maintainer note (@bolichen97, agent-assisted): pushed a merge commit |
|
Maintainer note (agent-assisted, on behalf of @bolichen97): the branch is in conflict with |
Round: the two blocking findings, three remnants, and a rebase onto current mainSquashed to a single commit and rebased onto GPT 5.6 blocking — the session plan silently omitted portability findingsConfirmed and fixed.
Worth recording how the test was wrong first: the initial version patched GPT 5.6 blocking — malformed task entry crashed the serializerAn earlier round validated the outer list shape, but a scalar entry still Remnants of the earlier subtraction
What the rebase surfaced
Conflict resolutions were additive in the two append-only registries. In Verification
Two failures that are not this branch's
Still needs a human: Screenshot Evidence (this PR does change visual |
Round: the four items attributable to this branchPushed The one real test failure was mine
Both dispatchers now sit in GPT 5.6 blocking — feature-map labelsUpheld and correct. Rows 71 and 249 named the menu item Move to crew… while GPT 5.6 finding — the session hydration was half doneThis is the substantive one. The ledger is hydrated. The GPT 5.6 finding —
|
Round: two blocking findings that my own last round createdPushed The previous round's spawn-audit failure is fixed and both shards are green. GPT Findings are redacted at every egress — a path my ledger fix opened
This is the third instance of one class in this PR: requirement identities leaked Worth naming precisely what the fix does and does not do. The redactors replace A scalar
|
Round: the frontend failures were three catalog violations of minePushed Root cause, and why my local run had said green
Three violations, all introduced by this branch:
The French fix is a JSON Worth recording why my own local run had reported these files green: the style What the rebase surfaced
One environment note for anyone reproducing locally: after a rebase this large, VerificationBackend: One scope question for you
Still outstandingScreenshot Evidence, and with it the UX and Design BLOCKs, for the reasons in the |
Round: GPT's two blocking items, and a section-number collisionPushed Malformed task collection crashed the mid-run checkThis is the third variant of one class, and the reason there was a third is that I The check now lives once in I did NOT add a handler on the dashboard path, and that is deliberate rather than Raw buttons replaced with the shared primitiveBoth now use The conflict was a section-number collision, not the usual registryUpstream added VerificationBackend: One environment note, the second time it has bitten: after a large rebase, Two items that are not code findings
Still human-onlyScreenshot Evidence and the code owner review from |
Round: every code-level finding is now cleared; two UX Watch items fixedPushed Since UX and Design both BLOCK solely on missing evidence ("cannot evaluate"), the Fixed — the Schedule row misused
|
Screenshot evidence is now in the descriptionSeven captures are embedded in the PR description and render inline: the They are hosted on an orphan branch of the fork The Screenshot Evidence gate re-ran on the Two gaps remain named, not papered overThe task-run menu shots need a real task-runner run, and the What capturing these found, in case it is useful beyond this PRThe first captures were of a five-week-old bundle: the gateway serves The second finding was a real defect in this branch, caught only by looking at the |
Round: the frontend failure was two restyle-ratchet violations of minePushed
|
Round: rebased onto current
|
Request: the three remaining blocking verdicts are not readable by a fork authorHead What I checked, and where the content is notFor
The
|
| head | verdict |
|---|---|
32663d147b |
changes requested — 1 of 1 withheld |
cd22f015d9 |
no blocking findings |
d8fa6491cb |
changes requested — 2 of 2 withheld |
git diff cd22f015d9 d8fa6491cb is 5 changed lines in two files: website/src/i18n/locales/hi.json and website/src/i18n/locales/ru.json. They are translated UI strings, reworded from the formal register to the informal one so hiStyle.test.ts and ruStyle.test.ts would pass. A register change to five translated strings is an implausible origin for two new security-class findings.
Two. On this same head, this repository's own Security Scope Review concludes "nothing to scope — no security-surface path touched." Two gates in the same pipeline disagree about whether the change touches a security surface at all.
The adjudication lane that would resolve a withheld finding does not run on forks
The verdict says the findings were withheld from adjudication. On this head:
Security scope adjudication (${{ matrix.os }})— skippedSecurity scope candidate validation— skipped
So the class of PR that produces a withheld finding is the class where the mechanism that could resolve it does not execute. I do not think this is a deliberate policy position; it reads like an interaction between the fork lane and the adjudication lane that nobody chose.
What I am asking for
Any one of these unblocks it, and I have no preference between them:
- Surface the two
GPT 5.6 Reviewfindings to me in whatever redacted form is safe — a file and a category is enough to work from. - Post or re-run the
UX Review/Design Reviewcomment ford8fa6491cb, or move their bodies intooutput.summaryasFirst Principles Reviewalready does. - Tell me the three are accepted as advisory for a fork contribution, and the readiness gate can carry them.
Not claiming these are false
I cannot see the GPT findings, so I cannot rule out that they are real — and that asymmetry is the whole difficulty: the evidence needed to act sits on the side that is not the author's. If they are real I want to fix them.
For the same reason I want to be clear about what was mine in the earlier rounds, because most of it was: 2,494 build artefacts committed by a careless git add -A, which broke three scanning gates at once; conflict markers that reached a commit because I ran rebase --continue without re-verifying; a layout defect where a line-clamp bounded lines rather than width; two restyle-ratchet violations; and the five locale register violations above. Every gate that gave a legible refusal named a real defect of mine and was fixed in one round. First Principles Review's four scope items are also fair in kind, and I have asked the PR author to decide on them rather than acting unilaterally.
Round: took First Principles Item 5 — the four peer buttons are backPushed What went back
One deliberate exception to "restore verbatim": the Chat button's hand-off prompt keeps the Item 9 resolved by the same editWith the Tests went back tooFive pre-existing tests in The change's file count drops from 60 to 58. Verification
I checked the specs and docs for claims that asserted the regroup and found none to correct: Items 4, 6 and 8 are still open and are the PR author's call, not mine to take unilaterally. |
Round: Items 4 and 6 taken, and the mutation sweep now has a CI consumer (Item 8)Pushed Item 4 — the
|
|
Rebased onto Four conflicts, all resolved by keeping the upstream side and re-applying this branch's addition. Three were adjacency; one was a restructure and is worth calling out.
That shape is required rather than preferred:
Re-verification, not just a SHA swap. The Also in this push: an unused Verification on the rebased tree.
Screenshot evidence in the description is unaffected — the images live on a separate branch of the fork, not in this diff. |
|
Rebased onto One conflict, in The previous head's backend reds were Verified on the rebased tree after
|
|
Status note for anyone picking this up. The PR stays open for review; it is not abandoned. Checks on head The branch is Checked before continuing:
None of these reassigns an owning crew. What would unblock merging:
|
|
PR triage (automated, REST-only audit at
|
|
Thanks @bolichen97 for the triage. I've addressed both findings, rebased onto The two defects
Rebase notes
Verified locally
Thanks also for pointing out that The two product questions on #7577 are still open for a maintainer: whether the project wants crew-to-crew migration at all, and if so, whether to review it as small PRs starting with cron end to end. This push keeps #8077 current and correct while that decision is pending. It doesn't presume the answer. |
Given a live cron job, chat session or task-runner run, describe what moving
it to another crew would involve: which fields would ship, which are dropped
and why, and what the target must satisfy first. Reachable from the Schedule
row menu, the session menu, the task-run overflow, three POST endpoints and
the cron/taskrun move CLI verbs.
Nothing here transfers ownership, and the surfaces say so.
WHY THE TRANSFER HALF IS NOT IN THIS PR
--------------------------------------
An earlier revision also carried the five-step coordinator (quiesce ->
transmit -> await durable ack -> tombstone + release), a receiver, an
in-flight journal, a tombstone registry and a redirect badge. Review was
right that it should not ship: every migrate/reconcile/receiver call site
was a test. Two consequences that only reading the call graph shows --
* nothing in production ever wrote a tombstone, and production built all
three adapters with no registry at all, so the Schedule page's redirect
badge could not render for two independent reasons;
* the session move verb refused with exit 2 and told the user to move it
from the dashboard instead, where the endpoint also only planned. The one
surface named as capable was not capable.
The double-execution harm the issue names is removed by a real transfer, never
by a description of one, so the coordinator, the receiver, the journal, the
tombstone registry, the badge and the adapters' quiesce/materialize/tombstone
steps are all deferred to the change that wires transmit to the crew tunnel --
where they get a production caller and become testable end to end. Guards in
the adapter and protocol tests fail if any of them returns without it.
The mid-run refusal stayed, because it IS reachable: planning a move for a run
with a task in flight would describe something that cannot happen. It is now
its own refuse_if_mid_run check rather than a side effect of the transfer's
quiesce step.
FIELD DISCIPLINE
----------------
Each adapter ships an explicit allow-list; anything unnamed is dropped, and a
drift guard fails when a field is added without a decision. That guard caught
upstream's new cron secret-grant fields, which are dropped: secret_env is
minted only by an owner approving a request on the Schedule page, precisely so
an agent cannot grant itself vault access, and shipping it would make
migration that bypass. Shipping would also be useless -- the values are secret
NAMES resolved against the source host's vault, and secret_env_pin is a keyed
epoch-bound HMAC that cannot verify on the target.
SECRECY AT EVERY BOUNDARY
-------------------------
A requirement's identity quotes operator-authored text verbatim, so it can
carry a credential. Both boundaries scrub it: the dashboard redacts before
serializing a plan to the browser, and the shared CLI plan renderer redacts
before printing, additionally REPLACING C0/C1 controls so a terminal sequence
cannot drive the terminal and removal cannot splice two fragments into one
token. The sanitizer lives at the shared renderer because a per-verb copy is
what let the task-run verb keep printing raw identities after the cron verb
was fixed. The runs-file flag now reads through the sensitive-path gate.
A non-string target is refused with a structured 400 instead of crashing. The
move audit resolves kiro_crew.sel -- both copies of that helper previously
imported a module that does not exist, and each caller's except turned it into
one debug line, so no move was ever recorded while every endpoint still
returned 200. The dead copy in protocol.py is deleted with the coordinator.
An app token cannot probe for slots it does not own: the session route runs the
same ownership check the other slot-scoped endpoints use, so a 404-vs-200 split
does not itself disclose that a session exists. An unstable snapshot answers a
retryable 503 rather than a 500.
The session plan reads the slot's own project / model / workspace, and its
session ledger. The transfer builder carries only `agent` of the four references
SESSION_NONPORTABLE names and produces no ledger key at all, so a plan built from
it alone reported one drop, stayed silent about the other three, and never ran
the ledger carry or the host-local-artifact findings that `serialize` promises.
For a project-bound session, the common case, that understates exactly what the
plan exists to disclose. They are classifier inputs, stripped from the payload
and reported as findings, so nothing extra would travel.
There is deliberately no mcp_server requirement. Nothing can say which servers a
session loaded: `mcp_discovery.list_servers` takes no arguments, returns the
host's whole configured inventory, and disclaims knowing what kiro-cli loads at
session time. Emitting that inventory would block on servers the session never
touched, and the only producer of the key the branch read was its own tests, so
the promise is removed rather than fed a fabricated input.
Plan findings are redacted at every egress. A finding's `detail` and
`detail_key` are not always product-authored: a ledger finding names the artifact
KEY an agent wrote through `session_ledger_record` and embeds it in its sentence,
so making the ledger reachable also opened a third path for a credential to reach
a consumer. Both the dashboard serializer and the task-run CLI print now apply
the same two redactors a requirement identity gets.
Malformed run records are refused by name rather than crashing: a scalar in the
task list reached dataclasses.asdict, a scalar runs.json reached the list
iteration, and a scalar `commit_hashes` reached `len()`, all surfacing as a
traceback to a CLI user.
A cron job's member and memory store are dropped and reported as blocking
requirements. `require_memory_store` compares the job's `memory_store` with the
member's own binding and raises `memory_unavailable` when they disagree, so a
shipped value either fails closed at fire time or binds the job to a store the
target's owner never granted; `member_id` names a member of the source crew's
roster. Naming them in the plan is the point -- dropping them silently would
have the user find out when the job next fires. The template provenance pair
ships (it describes the job), the retry telemetry does not (it describes a run
on the source host).
The dialog's error notice can be dismissed. Its crew-lookup message is derived
from the query rather than stored, so a dismiss wired only to the stored error
left a visible control that did nothing.
Two dispatchers join BENIGN_SPAWNS. The spawn audit's AST heuristic reads
`<alias>.run` as a subprocess spawn, and these drive the async plan builders from
the loop-less CLI: no child process, no argv. Same classification, and the same
file, as `_cleanup_app_crons_from_scheduler`.
Refs kirodotdev#7577 -- this PR does NOT close it. Every surface here is plan-only, and
the double-execution harm the issue names is removed by a real transfer, so the
issue stays open until the change that wires transmit lands.
|
Correction to my comment of 2026-09-30. In that comment I said the UX, Design and First Principles review comments did not exist, and that GPT's findings could not be read. That was wrong. The bot comments were created on 2026-09-05 and are edited in place on every push, so they keep their original creation date. I filtered comments by creation time and missed them. I'm sorry for the noise. Only one part of that comment still stands: GPT's security-class finding is withheld from adjudication. What this push changes. The head is now
Not in this push, waiting on direction from #7577.
Two other checks.
Verified on the rebased tree.
|
|
Thank you @timwukp for the careful work and for keeping this rebased and answering every review. We are closing it for now because the underlying request in #7577 is parked pending a maintainer decision, and this PR carries its own RFC that has not been accepted yet. A good next step would be a docs-only PR with rfc-crew-work-migration.md so the design can be agreed first; once it is accepted, the plan and transfer code can follow against current main. #7577 stays open to track the need. The branch is left untouched, so you can reopen this PR at any time, or open a fresh one on current main, if you want to pick it back up. |
Problem / Motivation
Goal: Let a user see, from the dashboard, exactly what moving a cron job, chat session or task run to another crew would carry and require — a plan only; nothing is moved yet.
Refs #7577 — this PR does not close it. See the scope note below.
Moving a live work unit — a cron schedule, a chat session, a task-runner run —
from one crew to another has no supported path today.
session_transfer.pydocuments "Copy, never move", and no code path releases ownership of anything.
So the only way to relocate work is to recreate it by hand on the target and
remember to disable it on the source, which is exactly how a unit ends up
executing on two crews at once, or on neither.
Why it matters
The dangerous part of a move is not the copying, it is the ownership. A cron
job that fires on both crews runs the same side effects twice. A job that fires
on neither is silently lost, and looks identical to one somebody paused.
Not a goal
session moveverb.What changed (motivation → approach → change)
The plan, and only the plan. Given a unit, describe what moving it would
involve: which fields would ship, which are dropped and why, and what the
target must satisfy first (its agent, its MCP servers, a project checkout, a
script path, a command policy, a git repo).
Reachable from:
⋯→ Preview a move to crew…⋯→ Preview a move to crew…POST /api/crons/{job_id}/move,.../taskrunner/{task_id}/move,.../chat/slots/{slot}/movecron move,taskrun moveNothing transfers ownership, and every surface says so. The dialog, the CLI
output and the endpoint responses all state that this is the plan only.
Why the transfer half is NOT in this PR
An earlier revision of this branch also carried the five-step coordinator
(quiesce → transmit → await durable ack → tombstone + release), a receiver, an
in-flight journal, a durable tombstone registry, and a redirect badge on the
Schedule page.
Review was right that it should not ship, and reading the call graph shows why
it was worse than "not wired yet":
migrate()/reconcile()/ receiver call site was a test.three adapters with no registry at all (the parameter defaulted to
None). So the redirect badge could not render, for two independent reasons.kirocrew session moverefused with exit 2 and told the user to move it fromthe dashboard instead — where the endpoint also only planned. The one surface
named as capable was not capable. That verb is no longer in this change at all:
with no transfer to perform it could only refuse, so it would be permanent
command-group surface that exists to say "not here". A session move is planned
from the dashboard, which is the surface that holds the slot.
The harm #7577 names is removed by a real transfer, never by a description of
one. So the coordinator, the receiver, the journal, the tombstone registry, the
badge, and the adapters'
quiesce/materialize/tombstonesteps aredeferred to the change that wires transmit over the crew tunnel, where they get
a production caller and become testable end to end.
Guards keep them out until then.
test_the_transfer_half_is_absent_from_this_sliceand
test_the_transfer_steps_are_absent_from_the_plan_adapterfail if any ofthose names returns without its wiring, and a mutation proves those guards have
teeth.
The mid-run refusal stayed, because it is genuinely reachable: planning a
move for a run with a task in flight would describe something that cannot
happen. It is now its own
refuse_if_mid_runcheck rather than a side effect ofcalling the transfer's quiesce step for its exception.
Field discipline
Each adapter declares an explicit allow-list; anything unnamed is dropped, and a
drift guard fails when a field is added to the underlying dataclass without a
ship/drop decision.
That guard earned its place during this PR: it caught upstream's new cron
secret-grant fields. All five are dropped.
secret_envis minted only by anowner approving a request on the Schedule page, precisely so an agent cannot
grant itself vault access — shipping it through a migration would make migration
that bypass, handing the target's owner an authorization they never gave.
Shipping would also be useless: the values are secret names resolved against
the source host's vault, and
secret_env_pinis a keyed, epoch-bound HMAC thatcannot verify on the target. A pending request still awaits the source owner's
decision and must not be inherited by an owner who never saw it.
Secrecy at every boundary
A requirement's identity quotes operator-authored text verbatim (a cron job's
command), so it can carry an inline credential. Both output boundaries scrubit:
browser. The unredacted identity stays in the internal bundle.
control characters: a terminal sequence survives redaction untouched and would
otherwise drive the terminal, and replacing rather than removing means the
removal cannot splice two previously separated fragments into one token.
The sanitizer lives at the shared renderer rather than in each verb, because a
per-verb copy is exactly what let the task-run verb keep printing raw identities
after the cron verb was fixed.
--runs-fileis caller-supplied, so it now reads through the sensitive-pathgate — a JSON decode error quotes the offending text, so an unguarded read could
have put a credential file's contents on stderr.
Two defects worth calling out
The audit never fired.
_auditresolvedkiro_crew.security_event_log,which does not exist.
_audit'sexcept Exceptionturned theModuleNotFoundErrorinto a single debug line, so no move was ever recordedwhile every endpoint still returned 200. Fixed to
kiro_crew.sel, with a testthat patches the real
kiro_crew.sel.seland assertslog_api_accessactuallyfires — a fail-open audit needs a test that proves it ran, not one that proves
it was called.
A non-string target crashed.
to_crew: 123reached.strip()and returned500. It is now a structured 400.
Tests
verbs and the security-posture guards.
task-run page and the i18n gates.
consumer:
test/test_migration_mutation_anchors.pyasserts every mutation'sanchor still resolves exactly once, names a test file that exists, changes the
line at all, and is paired with the runner that can read its test. It reads the
table without mutating anything, so it costs milliseconds inside the ordinary
backend suite — the full sweep stays a manual deep check, but it can no longer
rot unnoticed between runs. Every mutation targets code a user can reach; the
transfer half's mutations left with the transfer half, because a mutation
proving a test has teeth is worthless when nothing in production drives the
code it mutates.
Manual verification
kirocrew cron move <job> --to ec2prints the plan, names the blockingrequirements, and states that it is the plan only.
commandcontaining an AWS key and an OSC title-set sequence printswith the credential redacted and the control sequence replaced.
--runs-filepointed at a credential path is refused by the path gate.surface that can plan one.
Screenshots / video
None attached, and this PR does change visual surfaces — so this is a gap, not
a waiver. I am explicitly NOT claiming an absence of visual change: the move
dialog, three entry points and a new error surface on the Schedule row are all
user-visible.
The earlier revision's only screenshot showed the Schedule page's redirect badge.
That badge is deleted here (it could never render in production), so re-using it
would evidence a surface this PR does not ship. It was removed rather than
re-pointed.
Needed, per the UX review's evidence gaps:
session
⋯, task-run overflow)rendered plan with requirements and findings
Happy to take these once someone can run the dashboard, or to have a maintainer
apply
no-screenshotsif the plan-only surface is not considered worth theround trip.
Related Issues
Refs #7577. Deliberately not
Closes: every surface here is plan-only, andthe harm the issue names is removed by a real transfer. Merging this must not
auto-close the issue.
Checklist
tsc -b, ESLint, i18n gates, jscpd and phantom-class gate cleanScreenshot evidence
Seven screenshots, captured from a gateway seeded
with the
richfixture plus one planted failing cron job so the new Schedule-rowerror surface has something to render. They are of the code on this branch: the
dashboard bundle was rebuilt and staged into
src/kiro_crew/static/distfirst, forthe reason in "What capturing these found" below.
The images live on an orphan branch of the fork (
evidence/pr-8077-screenshots)rather than in this PR, so the reviewed diff carries no binaries. Nothing on that
branch is intended to merge.
The
Preview a move to crew…item, in two of its three menus. Schedule row⋯:Session
⋯— one shared label, so the entry points cannot drift apart:MoveToCrewDialog, three states. Empty — the heading readsPreview moving fixture-cron-01 to another crew, naming the unit by id with no implementationvocabulary interpolated into it:
The validation hint, after pressing Preview move with no target. It sits beside
the field and no error box appears — these are two separate surfaces now, so a
failed request can no longer wipe the hint or the draft:
A rendered plan. The plan-only correction leads the panel as an unmuted warn box
rather than trailing it in small print:
What capturing these found
Two defects, both caught by looking at rendered output rather than at code:
src/kiro_crew/static/dist, not thewebsite/distthatvite buildwrites,and the served copy predated this branch entirely. Screenshots taken then would
have looked like passing evidence while containing none of this PR's surfaces.
last_errorin the Schedule status cell, andvariant="inline"is aninline-flexrun built for a button row: with no width bound it rendered on oneline and painted across the Last Run and Next Run columns, because
line-clamp-2bounds height, not width. It was fixed with a bounded wrapper, and the surface
was then removed from this change altogether — it is a real accessibility
improvement (a hover
titleis unreachable by keyboard and screen reader) butunrelated to migration, so it belongs in its own change. Its two screenshots came
out of this description with it.
Two gaps, named rather than papered over
The task-run menu shots are missing. They need a real task-runner run and the
richfixture ships noruns.json. Hand-writing one puts the runner into_snapshot_recovery_incomplete— a degraded state, which is not an honest thing tophotograph.
The dialog's request-error state has no natural trigger.
to_crewis validatedbut never resolved by any layer, so every well-formed target returns a plan. No
input makes the request fail.
On the
Couldn't load the agent list.banner that appears above the table in afull-page view — which is why the Schedule shot is cropped to the table under review.
It is pre-existing and unrelated to this PR. The Schedule page has no chat session,
so
_skfalls back to the syntheticdashboard:uikey, which this fixture gatewayhas no slot for and answers 404
slot_not_found; the catalog is served fine with nokey at all.
useAgents.tsandAgentSelector.tsxare untouched by this branch,dashboard:uiappears 11 times inorigin/main'sclient.ts, anduseAgents(0)on this page is main's own call. It deserves its own issue — a page with no session
sending a key the backend rejects, then reporting the roster as unloadable — but not
a fix inside a migration PR.