Skip to content

feat(migration): plan a crew-to-crew work move - #8077

Closed
timwukp wants to merge 1 commit into
kirodotdev:mainfrom
timwukp:feat/crew-work-migration-slice1
Closed

timwukp wants to merge 1 commit into
kirodotdev:mainfrom
timwukp:feat/crew-work-migration-slice1

Conversation

@timwukp

@timwukp timwukp commented Sep 3, 2026 •

Copy link
Copy Markdown
Contributor

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.py
documents "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

  • Performing the transfer (quiesce → transmit → ack → tombstone); see "Why the transfer half is NOT in this PR".
  • A CLI session move verb.
  • Inline error surfacing in the Schedule status column.
  • Regrouping the task-run header buttons.

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:

Surface Entry point
Schedule row ⋯ → Preview a move to crew…
Session menu ⋯ → Preview a move to crew…
Task-run detail overflow → Preview a move to crew…
HTTP POST /api/crons/{job_id}/move, .../taskrunner/{task_id}/move, .../chat/slots/{slot}/move
CLI cron move, taskrun move

Nothing 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":

  • Every migrate() / reconcile() / receiver call site was a test.
  • Nothing in production ever wrote a tombstone — and production constructed all
    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 move 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. 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 / tombstone steps are
deferred 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_slice
and test_the_transfer_steps_are_absent_from_the_plan_adapter fail if any of
those 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_run check rather than a side effect of
calling 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_env is minted only by an
owner 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_pin is a keyed, epoch-bound HMAC that
cannot 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 scrub
it:

  • Dashboard — identities are redacted before a plan is serialized to the
    browser. The unredacted identity stays in the internal bundle.
  • CLI — the shared plan renderer redacts, and additionally replaces C0/C1
    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-file is caller-supplied, so it now reads through the sensitive-path
gate — 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. _audit resolved kiro_crew.security_event_log,
which does not exist. _audit's except Exception turned the
ModuleNotFoundError into a single debug line, so no move was ever recorded
while every endpoint still returned 200. Fixed to kiro_crew.sel, with a test
that patches the real kiro_crew.sel.sel and asserts log_api_access actually
fires — 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: 123 reached .strip() and returned
500. It is now a structured 400.

Tests

  • 146 backend tests across the migration package, the three endpoints, the CLI
    verbs and the security-posture guards.
  • 262 frontend tests across the dialog, the menus, the Schedule page, the
    task-run page and the i18n gates.
  • 28/28 mutations caught, 0 skipped, and the sweep now has an automated
    consumer: test/test_migration_mutation_anchors.py asserts every mutation's
    anchor 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 ec2 prints the plan, names the blocking
    requirements, and states that it is the plan only.
  • A cron command containing an AWS key and an OSC title-set sequence prints
    with the credential redacted and the control sequence replaced.
  • --runs-file pointed at a credential path is refused by the path gate.
  • A session move has no CLI verb: the dashboard holds the slot, so it is the only
    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:

  • the Preview a move to crew… item in each of its three menus (Schedule row,
    session ⋯, task-run overflow)
  • the dialog in each state: empty input, validation hint, request error, and a
    rendered plan with requirements and findings
  • the task-run More actions overflow, open

Happy to take these once someone can run the dashboard, or to have a maintainer
apply no-screenshots if the plan-only surface is not considered worth the
round trip.

Related Issues

Refs #7577. Deliberately not Closes: every surface here is plan-only, and
the harm the issue names is removed by a real transfer. Merging this must not
auto-close the issue.

Checklist

  • Backend lint (flake8 / isort / black) clean
  • Docs lint, feature-map gate and brand gate clean
  • tsc -b, ESLint, i18n gates, jscpd and phantom-class gate clean
  • Mutation sweep 14/14, none skipped
  • Feature-map rows corrected to say plan-only
  • Module spec no longer cites the removed module as present

Screenshot evidence

Seven screenshots, captured from a gateway seeded
with the rich fixture plus one planted failing cron job so the new Schedule-row
error 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/dist first, for
the 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 ⋯:

Schedule row overflow menu showing Preview a move to crew

Session ⋯ — one shared label, so the entry points cannot drift apart:

Session overflow menu showing Preview a move to crew

MoveToCrewDialog, three states. Empty — the heading reads Preview moving fixture-cron-01 to another crew, naming the unit by id with no implementation
vocabulary interpolated into it:

Move dialog, empty input

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:

Move dialog showing the target-required hint

A rendered plan. The plan-only correction leads the panel as an unmuted warn box
rather than trailing it in small print:

Move dialog showing a rendered plan led by the plan-only note

What capturing these found

Two defects, both caught by looking at rendered output rather than at code:

  1. The first captures were of a five-week-old bundle. The gateway serves
    src/kiro_crew/static/dist, not the website/dist that vite build writes,
    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.
  2. An inline error notice overran its cell. A revision of this branch rendered
    last_error in the Schedule status cell, and variant="inline" is an
    inline-flex run built for a button row: with no width bound it rendered on one
    line and painted across the Last Run and Next Run columns, because line-clamp-2
    bounds 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 title is unreachable by keyboard and screen reader) but
    unrelated 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
rich fixture ships no runs.json. Hand-writing one puts the runner into
_snapshot_recovery_incomplete — a degraded state, which is not an honest thing to
photograph.

The dialog's request-error state has no natural trigger. to_crew is validated
but 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 a
full-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 _sk falls back to the synthetic dashboard:ui key, which this fixture gateway
has no slot for and answers 404 slot_not_found; the catalog is served fine with no
key at all. useAgents.ts and AgentSelector.tsx are untouched by this branch,
dashboard:ui appears 11 times in origin/main's client.ts, and useAgents(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.

@timwukp
timwukp requested review from a team and krishdhasmana September 3, 2026 04:30
@github-actions github-actions Bot added fork Pull request from a fork (external contributor) readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Sep 3, 2026
@timwukp
timwukp force-pushed the feat/crew-work-migration-slice1 branch from 917cf6e to 8d163ca Compare September 3, 2026 04:37
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Sep 3, 2026
@timwukp

timwukp commented Sep 3, 2026

Copy link
Copy Markdown
Contributor Author

CI is held pending workflow approval — could a maintainer approve the runs?

This is a fork PR, so PR Readiness reports
3 workflow(s) awaiting maintainer approval; none has run yet. Everything that
can run without approval is green:

Check State
Fork PR Description pass
Publish readiness signal pass
Strip stale workflow-change override pass
Fork workflow-change guard skipping (no workflow files touched)
PR Readiness fail — awaiting workflow approval

mergeable: MERGEABLE against current main. Until the runs are approved there
is no CI signal either way, so PR Readiness is the only failing check and it is
not something I can clear from this side.

Two notes so review isn't wasted:

  • The description leads with what is NOT wired, deliberately: zero production
    call sites for MigrationCoordinator / migrate() / reconcile(), no transmit
    transport, reconcile() has no startup caller, and Requirement 7.2 is
    undemonstrable because nothing produces a success to show the target identity
    on. Refs #7577, not Closes — this is the protocol, the adapters and the
    planning surfaces, not an end-to-end move.
  • Screenshots / video is kept rather than deleted, and says why it is empty.
    The change does touch user-visible UI (a "Move to crew…" action on three
    surfaces, and a migrated-to badge in the Schedule status cell), so per the
    template that section is mandatory. Rendering it honestly needs a live gateway
    with a genuinely tombstoned cron job; a mocked screenshot would assert nothing
    the component tests don't already assert. Glad to add real ones if you'd prefer
    them before review, or to treat it as a blocker.

I'll avoid further force-pushes unless you ask for changes — the earlier one reset
a workflow approval that had just been granted, and I'd rather not do that to you
twice.

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention merge conflict Branch has merge conflicts with its base — author must resolve before merge and removed readiness: checking Automated validation is still running labels Sep 3, 2026
@timwukp
timwukp force-pushed the feat/crew-work-migration-slice1 branch from 8d163ca to 565acb3 Compare September 3, 2026 08:46
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Sep 3, 2026
@timwukp
timwukp force-pushed the feat/crew-work-migration-slice1 branch 2 times, most recently from 20df833 to f954cee Compare September 4, 2026 02:54
@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Sep 4, 2026
@timwukp

timwukp commented Sep 4, 2026

Copy link
Copy Markdown
Contributor Author

Rebased onto current main (5df44de) and force-pushed — the branch is now mergeable, state=blocked (no conflicts; blocked only on the checks below).

Two structural conflicts came up while catching up to main and were resolved additively, not by choosing a side:

  • docs/request-for-change/README.md (the RFC index) — kept both new rows; re-verified this RFC's "nothing on main yet" claim against the new base before re-pinning the measurement commit.
  • docs/feature-map/README.md — kept my three new rows and upstream's rewritten "Monitor loops" row (upstream had added the bounded-monitor endpoints); dropped my stale copy of that row so it appears exactly once.

The rebase also exercised the drift-guard test I shipped with this PR: CronJob gained last_result_stamp / last_result_ts upstream, and the test refused to pass until both were given an explicit ship/drop decision — both DROP, same execution-history group as last_run_ts, since they describe a run on the source host.

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: black (26.3.1, the pinned version), eslint --max-warnings 0, tsc -b, the Brand-Name and Feature-Map gates run with their enforcing base ref, 184 migration tests, and the mutation sweep at 23/23. The Schedule-page screenshot in the body is re-pinned to this head's SHA and resolves.

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 Refs, not Closes, because the transmit transport is deliberately out of this slice (documented under "What is NOT wired"). Would appreciate a review when you have a moment.

@github-actions github-actions Bot added merge conflict Branch has merge conflicts with its base — author must resolve before merge and removed merge conflict Branch has merge conflicts with its base — author must resolve before merge labels Sep 4, 2026
@timwukp
timwukp force-pushed the feat/crew-work-migration-slice1 branch from f954cee to de09080 Compare September 5, 2026 01:05
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Sep 5, 2026
@github-actions github-actions Bot added the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Sep 8, 2026
@timwukp
timwukp force-pushed the feat/crew-work-migration-slice1 branch from 223a692 to 96133cb Compare September 10, 2026 02:13
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Sep 10, 2026
@timwukp
timwukp force-pushed the feat/crew-work-migration-slice1 branch from 96133cb to 2544081 Compare September 10, 2026 02:50
@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention labels Sep 10, 2026
@bolichen97

Copy link
Copy Markdown
Contributor

Maintainer note (@bolichen97, agent-assisted): pushed a merge commit 948384536 to your branch bringing main in (on top of the head you pushed a few minutes ago). The one conflict was the audit paragraph in docs/request-for-change/README.md; resolved as main's sentence list plus your rfc-crew-work-migration sentence. scripts/docs-lint.sh and the migration tests pass on the merged tree. No source changes.

@bolichen97

Copy link
Copy Markdown
Contributor

Maintainer note (agent-assisted, on behalf of @bolichen97): the branch is in conflict with main again, and the PR already carries 2 commits (yours + the earlier maintainer merge), which is the maximum code-review.yml accepts — so a second maintainer merge commit cannot help this time. Please squash to one commit and rebase onto origin/main; the fork workflow runs will be approved as soon as the new head is up.

@timwukp

timwukp commented Sep 15, 2026

Copy link
Copy Markdown
Contributor Author

Round: the two blocking findings, three remnants, and a rebase onto current main

Squashed to a single commit and rebased onto e6c555de7. mergeable should now
be clean; the branch was 424 commits behind.

GPT 5.6 blocking — the session plan silently omitted portability findings

Confirmed and fixed. build_transfer_bundle_async carries the transcript and the
context window, and of the four references SESSION_NONPORTABLE names it carries
only agent. So a plan built from it alone reported exactly one drop and said
nothing about project, model or workspace, nor about the project_checkout
and mcp_server requirements they imply. For a project-bound session — the
common case — the plan understated precisely what it exists to disclose.

_build_session_bundle now reads those three off the slot. They are classifier
inputs: the classifier strips them from the payload and reports each as a
finding, so nothing extra would travel. Absent stays absent — an empty value
would invent a reference rather than report one.

Worth recording how the test was wrong first: the initial version patched
_build_session_bundle, which is where the fix lives, so it proved nothing
either way. It patches the inner builder now.

GPT 5.6 blocking — malformed task entry crashed the serializer

An earlier round validated the outer list shape, but a scalar entry still
reached dataclasses.asdict and raised an uncaught TypeError, which a CLI user
pointing --runs-file at a hand-edited registry saw as a traceback. There is now
a MalformedRunRecord naming the offending type, and the CLI exits 1 with a
sentence.

Remnants of the earlier subtraction

  • describe() had four definitions and zero callers, including in tests. Removed
    from the protocol seam and all three adapters.
  • Three places still asserted scan_for_secrets runs, which has zero definitions
    since the transfer half came out: the Finding docstring, instances.md, and a
    checked box in tasks.md. All now say what the tree does — the scan belongs to
    the deferred transfer half, and with no transmit there is no payload leaving the
    host for it to guard.

What the rebase surfaced

test_ship_and_drop_partition_covers_every_cronjob_field failed on the new base:
upstream added six CronJob fields, and that test refuses to let a new field go
unclassified. The classification, with grounds:

  • member_id, memory_store → dropped, and reported as blocking
    requirements.
    require_memory_store compares the job's memory_store
    against 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. Dropping is right, dropping silently is not — that is
    the same defect class as the session finding above, so the plan names them.
  • last_retry_count, last_retry_run_ts → dropped. Attempts that happened on
    the source host; a target inheriting them reports someone else's retries.
  • source_preset, source_template_prompt → shipped. They describe the job, not
    the host. A target whose registry lacks the template just never shows the
    changed-prompt hint.

Conflict resolutions were additive in the two append-only registries. In
cli.md the session move row was also corrected: it said to use the
dashboard's session action, which reads as though the dashboard can complete a
handoff. It cannot — it owns the slot and so can build the plan against live
state, which is what the CLI's own refusal text says.

Verification

flake8, isort, black, mypy, comment-history (with the base ref, since that
gate's interface changed upstream), docs-lint, feature-map and brand-name all
clean. Frontend: tsc, ESLint, i18n, jscpd, phantom-class clean; 45 files /
726 tests green. Mutation sweep 22/22 caught, 0 skipped — including new
mutations for the session hydration, the malformed-record refusal and the memory
requirement, and a re-anchored one whose subject my own edit had moved.

Two failures that are not this branch's

  • test_cron.py::TestCronService::test_mutation_after_deeply_nested_load_does_not_overwrite_the_store
    fails identically on an untouched origin/main, and this diff touches neither
    cron.py nor its test.
  • The heavy workflows have not run on this branch since the squash: a fork PR
    needs a maintainer's workflow approval, and the force-push reset it. CI and
    Screenshot Evidence in the checks list belong to the previous head.

Still needs a human: Screenshot Evidence (this PR does change visual
surfaces, so a no-visual-delta justification would be false) and the code owner
review.

@timwukp

timwukp commented Sep 16, 2026

Copy link
Copy Markdown
Contributor Author

Round: the four items attributable to this branch

Pushed a35ec9664 (single commit, no rebase — the base has not moved since
e6c555de7).

The one real test failure was mine

test_spawn_audit::test_every_spawn_is_routed_or_allowlisted was the only
assertion failure in the run, and it accounted for both red shards (Linux 3.12 #4
and Windows #4). The audit's AST heuristic reads <alias>.run as a subprocess
spawn — run ∈ _SPAWN_ATTRS, asyncio ∈ _SPAWN_MODULES, receivers derived
per file — and cron move / taskrun move drive their plan builders with
_asyncio.run(...). No child process is created and there is no argv at all.

Both dispatchers now sit in BENIGN_SPAWNS with that justification, matching the
several existing entries of exactly this shape — including two in the same file
(_cleanup_app_crons_from_scheduler, _register_app_crons_to_scheduler). The
test passes on an untouched origin/main, so this was mine to fix, not inherited.

GPT 5.6 blocking — feature-map labels

Upheld and correct. Rows 71 and 249 named the menu item Move to crew… while
the shipped menu_label, shared by all three menus, is Preview a move to
crew…
— the schedule row was the only one updated when the label was renamed.
Both corrected; the task-run row now also names the overflow it lives behind.

GPT 5.6 finding — the session hydration was half done

This is the substantive one. requirements() read raw["mcp_servers"] and
serialize read raw["ledger"], and the transfer bundle carries neither
(bundle_version, origin, title, agent, messages, optional layer_b).
So the ledger carry and its host-local-artifact findings never ran for a real
session, and the mcp_server requirement never fired. Two different fixes,
because the two inputs are not equally obtainable:

The ledger is hydrated. session_ledger.read_state(slot_key) returns exactly
the shape carry_session_ledger consumes, is best-effort by contract, and is
read via asyncio.to_thread so a slow disk cannot stall the other dashboard
requests behind it. The new test asserts the observable effect — a host-local
ledger artifact now produces its finding, reported by key with the path absent
from the whole response.

The mcp_server requirement is removed, not fed. Nothing can say which
servers a given session loaded: mcp_discovery.list_servers takes no arguments,
returns the host's entire configured inventory, and its own contract disclaims
knowing what kiro-cli loads at session time. Emitting that inventory would attach
a blocking requirement for every server the host happens to configure,
including ones the session never touched — a plan refusing on grounds it cannot
support. The only producer of that key anywhere in the tree was its own tests,
which is the same "every call site is a test" pattern that justified removing the
transfer half. A test now guards the removal: the adapter emits no mcp_server
requirement even when handed a key by that name.

GPT 5.6 finding — --to-crew

Correct, but not where the finding placed it. --to-crew occurs zero times in
the code and docs, which consistently say --to; the single occurrence was in
this PR's own description. Fixed there. Registering an alias on three parsers to
match a mistaken description would have widened the CLI surface to accommodate a
typo.

UX Watch — the dismiss control was dead

Verified and fixed. suggestionsError is derived from the crew-list query rather
than stored, while onDismiss cleared only error, so the X did nothing whenever
the suggestions notice was the one on screen. It has its own dismissed bit now,
with a test that clicks the control.

Verification

flake8, isort, black, mypy, comment-history, docs-lint, feature-map clean.
Backend 353 passed across the migration, spawn-audit, session-transfer,
session-ledger and security-posture suites. Frontend tsc, ESLint, i18n,
jscpd, phantom-class clean; 132 files / 1955 tests green. Mutation sweep
25/25 caught, 0 skipped, with new mutations for the ledger hydration, the
mcp_server removal and the dismiss fix.

Not addressed, deliberately

The Design Watch item stands and needs a maintainer's call, not a unilateral
rename: POST /api/.../move and cron move / taskrun move do only planning
today, so when transmit lands those same names flip from read-only to
destructive. The UI label is honest; the wire and CLI names are not. Renaming them
now (/move/plan, move --plan) is a breaking change to names already in this
PR's docs, and accepting the future flip is a decision about the API's contract —
either way it should be yours.

Screenshot Evidence remains the blocker on both UX and Design, and both said
so explicitly ("Cannot evaluate"). Producing the shots needs a gateway with a
minted dashboard credential, which is outside what I can do here. The request for
the no-screenshots waiver, or the shots themselves, is still open.

@timwukp

timwukp commented Sep 17, 2026

Copy link
Copy Markdown
Contributor Author

Round: two blocking findings that my own last round created

Pushed 0e6fe55e3 — rebased onto b6ec82e02, single commit, MERGEABLE.

The previous round's spawn-audit failure is fixed and both shards are green. GPT
then found two new blocking items on a35ec9664; both are upheld, and both are
consequences of that same round rather than pre-existing.

Findings are redacted at every egress — a path my ledger fix opened

_finding_json rendered detail and detail_key raw. That was harmless while no
finding carried anything but product-authored text — and then the previous round
made the session ledger reachable, so carry_session_ledger began producing
findings whose detail_key IS the artifact key an agent wrote through
session_ledger_record, embedded in the sentence too. A key holding a token or a
credential-bearing URL therefore reached the browser verbatim.

This is the third instance of one class in this PR: requirement identities leaked
to the dashboard, then leaked again at the CLI, and now findings. The first two
were fixed at their serialization boundaries; this one is fixed the same way, and
the task-run CLI print at the other egress point is covered too — a grep for
finding text showed that print was the only other one, and the shared
render_plan does not emit findings at all.

Worth naming precisely what the fix does and does not do. The redactors replace
the credential and leave host and path ([REDACTED: credential]host/path), which
is the shared redactor's own contract and exactly the depth a requirement identity
gets. My first version of the test asserted the hostname was gone as well; that
demanded behaviour the redactor does not provide, so the test now pins the
guarantee that exists rather than inventing a stricter one. Widening the shared
redactor to treat hostnames as secrets would be a much larger change and does not
belong in this PR.

A scalar commit_hashes crashed the CLI

commit_count called len() on it. Same class as the malformed-task-entry
refusal added last round and the same registry can carry it — I fixed the task
list and missed its sibling field. Both now raise MalformedRunRecord, and the
CLI guard was widened to cover describe_discarded_progress, which is called
outside the block that already caught it.

Verification

flake8, isort, black, mypy, comment-history, docs-lint, feature-map clean.
Backend 294 passed. Frontend tsc, ESLint, i18n clean; 131 files / 1939 tests
green. Mutation sweep 27/27 caught, 0 skipped, including new mutations for the
finding redaction and the commit-hash guard.

The conflict was the RFC registry again, resolved additively: upstream's two new
sentences kept verbatim, this branch's one re-inserted, and its provenance claim
re-verified against the new base before the SHA was restated (kiro_crew/migration
still absent from main; Copy, never move still present in session_transfer.py).

Not mine

Backend Tests (Windows) (1) fails on
test_context_import_orders_do_not_form_a_cycle with
subprocess.TimeoutExpired after 30s — a slow-runner timeout, not a real cycle.
This diff touches none of agent_sdk, context or providers.acp, and the file
passes locally.

Screenshot Evidence — I cannot produce these, and here is exactly why

Both UX and Design are BLOCK for the same stated reason ("Cannot evaluate"), so
this is the one blocker I have been unable to clear. Two independent obstacles,
both established by testing rather than assumed:

  1. No browser can run on this host. Both the bundled Chromium and the headless
    shell fail at the loader: 16 shared libraries are missing (libatk-1.0.so.0,
    libX11.so.6, libxcb.so.1, libasound.so.2, libgbm.so.1 and others).
    This is not the sandbox — that message was a second-order symptom once
    Playwright supplied its own library path. Fixing it means installing a batch of
    GTK/X11 runtime packages system-wide, which is not mine to do to someone's host.
  2. The gateway is loopback-only by design. tunnel.enabled is false,
    dashboard.tailscale.enabled is false, and nothing is bound off-loopback, so a
    browser on another machine cannot reach a seeded instance without the operator
    forwarding the port from their own side.

For the record, a seeded gateway WAS booted successfully (--seed rich, plus a
planted failing cron so the new Schedule-row ErrorNotice has something to
render) and its API confirms the states the reviews want are present. What is
missing is a renderer, not the fixture.

Two of the requested shots also cannot come from the fixture at all: the
task-run menu items need a real task run, since rich ships no runs.json, and
fabricating one puts the runner into _snapshot_recovery_incomplete — a degraded
state, which is not an honest thing to photograph. And the dialog's request-error
state has no natural trigger: to_crew is validated but never resolved by any
layer, so every well-formed target returns a plan.

Requesting the no-screenshots waiver, or a maintainer's own look at the four
surfaces. I would rather report this gap plainly than satisfy the gate with
something that misrepresents what runs.

@timwukp

timwukp commented Sep 21, 2026

Copy link
Copy Markdown
Contributor Author

Round: the frontend failures were three catalog violations of mine

Pushed acabcd8bed — rebased onto c8f0f1be4, single commit.

Root cause, and why my local run had said green

Frontend Tests (1) and (2) failed on two diff-scoped i18n style gates, and
Frontend Coverage Merge plus Coverage Gate are its fail-closed downstream —
the gate logic requires frontend-test=success and this PR is neither
backend-only nor frontend-only. Nothing about those two was weakened; fixing the
root failure is the only correct move.

Three violations, all introduced by this branch:

  • components.moveToCrew.heading (fr) — a plain space before : where the
    register requires U+202F.
  • pages.projectsPage.optimize_plan_prompt (fr) — same.
  • components.moveToCrew.error_suggestions_unavailable (bn) — the honorific
    আপনি where the register requires তুমি. Changing the pronoun also changes
    the verb, so পারেন became পারো; leaving it would have been grammatically
    inconsistent.

The French fix is a JSON \u202f escape, not a literal entity — my first attempt
wrote &#8239;, which a React catalog renders as visible text rather than a
space. Verified by reading the parsed codepoint back (202f).

Worth recording why my own local run had reported these files green: the style
gates are [changed-values]-scoped and need a base ref to know what changed. I
had been setting I18N_BASE_REF for i18n-check.mjs but not for vitest, so the
changed set was empty and every assertion trivially passed. Running them without a
base ref is a false green, and running them against an origin/main the branch is
NOT based on is the opposite error — that over-reported 12 upstream values as mine
until I pointed it at the real base.

What the rebase surfaced

Project and CronJob each gained fields, and the ship/drop partition tests
refuse to let a new field go unclassified:

  • execution_context (both) → dropped. It is the memory identity again as a
    durable record — member_id, the store ref, the agent-namespace selection, the
    memory mode. Every part is host-resolved, and its own __post_init__ refuses a
    record whose member and store disagree, so it can be neither shipped nor split
    into a portable fragment. The target's obligation is already named by the
    crew_member and memory_store requirements, so dropping it discloses nothing
    less than before.
  • chat_folder_id (cron) → dropped. It names a folder in the source sidebar;
    by its own contract an id the target cannot resolve is treated as "not filed",
    so shipping it would at best dangle. Same class as folder_id.

One environment note for anyone reproducing locally: after a rebase this large,
npm ci in website/ is required before the frontend gates mean anything. A
newly pinned @tailwindcss/node made check-phantom-classes.mjs die with
ERR_MODULE_NOT_FOUND, which reads as a code failure and is a stale
node_modules.

Verification

Backend: flake8, isort, black, mypy, comment-history, docs-lint,
feature-map clean; 309 passed. Frontend: tsc, ESLint, jscpd, phantom-class
clean, i18n 19 checks PASS against the new base, 133 files / 1969 tests green,
and both previously-failing style gates green when run with the base ref CI uses.
Mutation sweep 27/27 caught, 0 skipped.

One scope question for you

pages.projectsPage.optimize_plan_prompt is mine but arguably should not exist in
this PR. Upstream's Chat action builds that prompt from a hardcoded English
string; while relocating the button into the overflow menu I localized it, which
added a key to 13 catalogs and is the reason one of these violations existed at
all. It is a real improvement but it is not #7577. I fixed the punctuation as
asked rather than reverting unilaterally — say the word and I will drop the key
and restore upstream's inline string, which shrinks the diff and removes the
surface.

Still outstanding

Screenshot Evidence, and with it the UX and Design BLOCKs, for the reasons in the
previous comment: no browser can start on this host (16 missing shared libraries)
and the gateway is loopback-only by design, so I cannot produce rendered evidence.
The no-screenshots waiver or a maintainer's own look is still the open ask.

@timwukp

timwukp commented Sep 22, 2026

Copy link
Copy Markdown
Contributor Author

Round: GPT's two blocking items, and a section-number collision

Pushed 8230f978ac — rebased onto current main, single commit.

Malformed task collection crashed the mid-run check

This is the third variant of one class, and the reason there was a third is that I
had been guarding each READER instead of the accessor they share. serialize and
describe_discarded_progress were validated in earlier rounds; refuse_if_mid_run
reads the same list at plan time, before either, so a scalar task_details still
reached it.

The check now lives once in _tasks(), which every reader goes through, and the
CLI translates MalformedRunRecord at the mid-run call site as well.

I did NOT add a handler on the dashboard path, and that is deliberate rather than
an omission: that endpoint plans from runner._runs, whose Project objects are
reconstructed by _load_runs with tasks built as a list — a scalar there fails
at gateway start, inside _load_runs, and cannot reach the endpoint. Guarding an
unreachable path is the thing this PR spent its life removing.

Raw buttons replaced with the shared primitive

Both now use Btn (which forwards its ref, so the Radix asChild trigger still
works). Worth being precise about provenance: the Restart button is upstream's own
and my diff only relocates it, so the gate sees an added line. Since I am moving it
anyway, converting it to the primitive this file already uses twice is within the
blast radius of my change rather than gratuitous. The icon-only trigger keeps an
explicit square footprint because Btn's default padding would widen the cell the
pinned actions column is sized for.

The conflict was a section-number collision, not the usual registry

Upstream added ## 16. The Fargate connection method; this branch also had a §16.
Both sections are kept and mine became §17 — including the 15 §16 self-references
inside it, its ### 16.x subsection numbers, the table-of-contents entry, and the
anchor cli.md links it by. A stale anchor would have passed docs-lint while
silently pointing at Fargate, so I grepped the whole tree: 0 references to the old
anchor remain.

Verification

Backend: flake8, isort, black, mypy, comment-history, docs-lint,
feature-map clean; 339 passed. Frontend: tsc, ESLint, i18n 19 checks PASS,
jscpd, phantom-class clean; 134 files / 2022 tests green. Mutation sweep
28/28 caught, 0 skipped, with a new mutation pinning the shared-accessor guard.

One environment note, the second time it has bitten: after a large rebase, npm ci
in website/ is required before the frontend gates mean anything. This time a
newly pinned @shadcn/lint made ESLint itself die with ERR_MODULE_NOT_FOUND,
which reads as a lint failure and is a stale node_modules.

Two items that are not code findings

Opus 4.8 Review reports "review incomplete" on this branch — its own verdict
comment is still pinned to an older SHA and the job failed in about a minute, so it
never produced a verdict. That is the review pipeline, not a finding against the
diff.

Backend Tests (Windows) (1) has been failing intermittently on
test_context_import_orders_do_not_form_a_cycle with a 30-second
subprocess.TimeoutExpired. It has also passed on this branch. The diff touches
none of agent_sdk, context or providers.acp.

Still human-only

Screenshot Evidence and the code owner review from kirodotdev/kirocrew-team.
The screenshot situation is unchanged and documented above: no browser can start on
this host (16 missing shared libraries) and the gateway is loopback-only by design,
so I cannot produce rendered evidence. The no-screenshots waiver, or a
maintainer's own look at the four surfaces, remains the open ask.

@timwukp

timwukp commented Sep 22, 2026

Copy link
Copy Markdown
Contributor Author

Round: every code-level finding is now cleared; two UX Watch items fixed

Pushed 8a6cf67002. GPT 5.6 and Opus 4.8 both report no blocking findings on
this branch, and CI is green across all 8 backend shards, all 8 Windows shards, all
4 frontend shards, Coverage Gate and Frontend Coverage Merge. What remains is
screenshot-gated plus the code owner review.

Since UX and Design both BLOCK solely on missing evidence ("cannot evaluate"), the
useful thing left was their Watch items. Two are defects on the surface this PR
adds, so they are fixed; the rest are answered below rather than left silent.

Fixed — the Schedule row misused ErrorNotice

The component's own doc says block is "the boxed banner at the top of a panel"
and inline is for sitting inside an existing row. I had put the block default
into a dense table cell, so several failing jobs would stack banners down the
status column, and the raw last_error was unclamped so a long message set the
row height. Now variant="inline" with line-clamp-2; the full text stays
reachable through the cell's existing title.

Fixed — the heading rendered a raw enum in all 13 locales

Preview moving {{unitKind}} … interpolated 'cron' | 'session' | 'taskrun'
verbatim, so every locale showed untranslated implementation vocabulary on the
feature's main surface, every open.

I removed the token rather than translating it. Adding localized nouns would have
meant 39 new translated values across 13 catalogs, and translations have been the
single most error-prone part of this PR — three catalog-style violations so far came
from mine. Deleting vocabulary carries none of that risk, and the token had no
reader to lose: the id identifies the unit, the menu it was opened from supplies
the kind, and the rendered plan states the bundle kind. The now-unused unitKind
prop and its three call sites went with it. en-XA was regenerated with
gen-pseudolocale.mjs rather than hand-edited.

Answered, not fixed — requirement kinds and the handoff id

script_path / mcp_server / "(blocking)" / "Handoff id" / "Bundle cron v1" are
the same class of machine token, and the observation is fair. I am not changing
them here: localizing the requirement kinds is another 39+ translated values, and
whether the handoff id and bundle row "earn their place in a preview" is a product
judgment about what a plan should disclose, not a defect I can settle unilaterally.
Both are one-file changes for a follow-up or a maintainer's call.

Answered, not fixed — Restart behind the overflow

Correct that this costs a returning user a hunt plus a click on what is often the
primary next step. I left it in the overflow because the alternative is exceeding
the two-control limit the row is sized for, which is what pushed the column off
screen in the first place. Which of those two costs is worse is a design call —
happy to promote Restart back to a peer if you prefer it.

Verification

Backend: docs-lint and comment-history clean. Frontend: tsc, ESLint, i18n
19 checks PASS against the current base; 134 files / 1994 tests green. Mutation
sweep 28/28 caught, 0 skipped — re-run because the dialog edits could have
moved a mutation anchor; none did.

The remaining blockers are not mine to clear

Screenshot Evidence, and with it the UX and Design verdicts: no browser can
start on this host (16 missing shared libraries — both the bundled Chromium and the
headless shell fail at the loader) and the gateway binds loopback only by design,
so I cannot produce rendered evidence. A seeded gateway was booted successfully and
its API confirms every state the reviews ask for is present; what is missing is a
renderer, not a fixture.

Code owner review from kirodotdev/kirocrew-team.

Requesting the no-screenshots waiver or a maintainer's own look at the four
surfaces. Every actionable item from every reviewer is now either fixed or answered
above.

@timwukp

timwukp commented Sep 23, 2026

Copy link
Copy Markdown
Contributor Author

Screenshot evidence is now in the description

Seven captures are embedded in the PR description and render inline: the
Preview a move to crew… item in the Schedule row and session menus, the
MoveToCrewDialog in its empty / validation-hint / rendered-plan states, the
Schedule jobs table, and the failing row's new inline error surface on its own.

They are hosted on an orphan branch of the fork
(timwukp/KiroCrew@evidence/pr-8077-screenshots) and linked by raw URL, so the
reviewed diff carries no binaries and nothing on that branch is meant to merge.
gh pr edit --attach needs write access to this repository, which a fork
contributor does not have, and a relative ./file.png link would satisfy the
gate's grep while showing reviewers a broken image — so neither was used.

The Screenshot Evidence gate re-ran on the edited event and is sitting at
action_required
, i.e. waiting for a maintainer to approve the workflow run.
The failure still shown in the checks list is the run from before the
description was updated. Nothing further is needed from me for that gate; it
needs the run approved.

Two gaps remain named, not papered over

The task-run menu shots need a real task-runner run, and the rich fixture
ships no runs.json; hand-writing one puts the runner into
_snapshot_recovery_incomplete, which is a degraded state and not an honest thing
to photograph. The dialog's request-error state has no natural trigger, because
to_crew is validated but never resolved by any layer, so every well-formed target
returns a plan.

What capturing these found, in case it is useful beyond this PR

The first captures were of a five-week-old bundle: the gateway serves
src/kiro_crew/static/dist, not the website/dist that vite build writes. Shots
taken then would have looked like passing evidence while containing none of this
PR's surfaces — worth knowing for anyone else producing visual evidence from a
local gateway.

The second finding was a real defect in this branch, caught only by looking at the
render: the new inline error overran its table cell and painted across the Last Run
and Next Run columns, because variant="inline" is an inline-flex run built for a
button row and line-clamp-2 bounds height rather than width. Fixed with a bounded
wrapper plus the component's own messageClassName, and shot 2 is the result.

@timwukp

timwukp commented Sep 24, 2026

Copy link
Copy Markdown
Contributor Author

Round: the frontend failure was two restyle-ratchet violations of mine

Pushed 1c951466af.

Frontend Lint & Type Check — restyle ratchet, both sites mine

npm run lint:restyle-ratchet refused two files that are not in website/scripts/restyle-baseline.json:

  • website/src/components/MoveToCrewDialog.tsx — space-y-4 on <DialogBody>. That primitive owns its own padding, so the class was restyling it from a call site. The rhythm belongs to the content, so it now sits on a plain wrapper div inside the body.
  • website/src/pages/ProjectsPage.tsx — text-danger focus:text-danger on <DropdownMenuItem>, twice. This arrived when the task-run action row became a menu in this change; the base spelled the same treatment on a raw <button>, where the rule does not apply.

For the second one the rule's own remedy is a variant in the primitive, so DropdownMenuItem gained a danger modifier following the inset idiom already in website/src/components/ui/dropdown-menu.tsx. It is additive and opt-in — no existing call site changes behaviour or appearance. The call site now passes danger instead of the class.

The baseline is unchanged and still records 349 sites in 51 files; the tree measures exactly 349 in 51, so this is a return to the ceiling rather than a raise.

Backend Tests (Windows) (7) — not reachable from this diff

test_runtime_cleanup_windows.py::test_windows_failed_owner_drain_recovers_after_owner_drop failed on assert {4956, 5088, 6916} <= {5088} — the retained pending tree held only its root. The test injects a discovery refusal at a fixed call index over real process trees, so the assertion is order-sensitive.

Attribution, rather than a claim of flakiness: this diff touches no file that test imports (platform_compat, session_pid, acp/runtime, acp/session_provider are all untouched), and scripts/ci_file_shards.py assigns a file to a shard by the sha256 of its path, so shard 7's file set is identical to main's — none of the ten test files this change adds or edits lands there. The last four main runs have all eight Windows shards green, which is consistent with an intermittent condition rather than a standing break.

The three advisory reviews

GPT 5.6 Review, UX Review and Design Review each report BLOCK with "see the PR comment", and no such comment has been posted for this head. GPT's check text adds that its one blocking finding is security-class and was withheld from adjudication. I cannot read any of the three, so I have not guessed at them — if a maintainer can surface the findings I will address them.

Verification

lint, typecheck, lint:theme-colors, lint:phantom-classes, lint:restyle-ratchet, lint:i18n, i18n:check all rc=0. Affected suites 108 passed. Mutation sweep 28/28 caught, 0 skipped. Brand-name, comment-history and feature-map gates green with the base ref pinned to the merge base.

@timwukp

timwukp commented Sep 24, 2026

Copy link
Copy Markdown
Contributor Author

Round: rebased onto current main, three conflicts resolved, one new upstream field classified

Pushed cd22f015d9, rebased onto 1f9c252ef4 (126 commits). mergeable is now MERGEABLE.

The three conflicts were all "upstream edited the same paragraph I append to"

Each was resolved by keeping upstream's version of the shared text and re-applying only this change's addition — never by choosing a side.

  • docs/feature-map/README.md, two hunks. Upstream had added user_only to the Older sessions row and renamed the Monitor loops row's surface to Work log; this branch carried the pre-rename copies of both. Upstream's rows are kept verbatim and the two rows this change adds (Move session to another crew, Move schedule to another crew) are re-applied beside them. The stale duplicates are gone — one | Older sessions row, one Monitor loops row.
  • docs/request-for-change/README.md. The audit paragraph is append-only; upstream appended rfc-host-credential-vending and a rfc-wake-judge re-audit. Upstream's text is kept whole and this change's one sentence follows it.
  • docs/system-specs/modules/instances.md. Upstream replaced the FargateEngine.register() no-op paragraph at the end of §16 with the real FargateLaunchEngine.register() description. Upstream's text is kept and §17 follows it; the stale no-op paragraph this branch carried is dropped. §17 is still free upstream — main's last section is §16.

No conflict marker reached the commit (git grep on HEAD).

The drift guard caught an upstream CronJob field

test_ship_and_drop_partition_covers_every_cronjob_field failed on run_generation, which upstream added while this branch was behind. That is the guard working as designed, so it is classified rather than silenced: dropped, for the same reason the retry telemetry beside it drops. It is a per-job counter allocated by the SOURCE host's CronService and it only orders merges of that host's runs; the target allocates its own from the value its own store holds, so a foreign number would seed the target's ordering with a count it never made. It is not a host-resolved reference, so it needs no HostRequirement — nothing on the target is checked against it.

Re-binding

rfc-crew-work-migration's status row is re-verified against the new merge base 1f9c252ef4. The RFC's one code-level caveat cites taskrunner.py's _serialize_runs at ebc0936; that file is unchanged between the old and new base, so the caveat still holds and is left as it is.

Verification on the rebased tree

npm ci first, since 126 commits can move a pinned dependency. Frontend: lint, typecheck, lint:theme-colors, lint:phantom-classes, lint:restyle-ratchet, lint:i18n, i18n:check all rc=0. Backend: flake8 clean, the baselined black gate passes in scope, isort clean, docs_lint clean, and brand-name / comment-history / feature-map pass with the base ref pinned to the new merge base. 164 backend tests pass across the nine migration suites plus test_spawn_audit and test_security_posture. Mutation sweep 28/28 caught, 0 skipped. mypy reports only cli.py's PidfdChildWatcher, a local Python 3.14 artifact absent on CI's 3.12.

@timwukp

timwukp commented Sep 24, 2026

Copy link
Copy Markdown
Contributor Author

Request: the three remaining blocking verdicts are not readable by a fork author

Head d8fa6491cb. The frontend failures from the previous round are fixed — all four Frontend Tests shards are green, and Opus 5 Review reports no blocking findings. PR Readiness still counts 3 blocking readiness item(s), and all three are reviewer verdicts whose content I cannot retrieve from any surface available to me. I have stopped guessing at them, and I am reporting what I observed rather than asking for an exception.

What I checked, and where the content is not

For UX Review and Design Review the check-run title and summary both say "see the PR comment". No such comment exists for this head. I looked in all four places a fork author can look:

  • GET /issues/8077/comments — nothing posted after 05:20 UTC, when this head was pushed
  • GET /pulls/8077/reviews — no review submitted for this head
  • the check runs' output.text — null
  • the check runs' /annotations — empty

First Principles Review shows the pattern that does work: it puts its full body in output.summary, so I could read all four of its items and act on them. The other reviewers point at a comment instead. That difference is what makes two of the three unactionable.

The GPT 5.6 Review verdict is not reproducible across heads

Its summary reads: "2 of 2 blocking finding(s) are security-class and were withheld from adjudication, so the blocking verdict stands." Withholding a security finding on a public fork PR is reasonable on its own terms. Two observations make it unresolvable from my side:

One. The verdict oscillated across three heads while the code did not change in any security-relevant way:

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 }}) — skipped
  • Security 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:

  1. Surface the two GPT 5.6 Review findings to me in whatever redacted form is safe — a file and a category is enough to work from.
  2. Post or re-run the UX Review / Design Review comment for d8fa6491cb, or move their bodies into output.summary as First Principles Review already does.
  3. 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.

@timwukp

timwukp commented Sep 24, 2026

Copy link
Copy Markdown
Contributor Author

Round: took First Principles Item 5 — the four peer buttons are back

Pushed 2f172800b5. The task-run header regroup is reverted; the overflow now carries exactly one item, the move this change adds.

What went back

Chat and Discard return as peer buttons on the planned row, and Restart and Schedule return on the legacy-status row, each with the markup and the condition they had at the base — including Restart's original status !== 'paused', which the regroup had narrowed to exclude completed and cancelled. No existing control has moved, so nobody relearns a position for this feature. The overflow trigger stays, holding Preview a move to crew… alone.

One deliberate exception to "restore verbatim": the Chat button's hand-off prompt keeps the pages.projectsPage.optimize_plan_prompt catalog key rather than reverting to the base's inline English "Let's optimize this plan:\n\n". Reverting that string would put a hardcoded English sentence back into a localized surface. If you would rather this change touch nothing there at all, say so and I will revert it too.

Item 9 resolved by the same edit

With the Discard menu item gone, the danger prop I added to DropdownMenuItem last round had no consumer — which is what Item 9 said. It is removed, and website/src/components/ui/dropdown-menu.tsx is now byte-identical to main: this change no longer touches a shared ui/ primitive at all. The restyle-ratchet gate still passes, because the restored Discard is the base's raw <button>, which the rule does not govern.

Tests went back too

Five pre-existing tests in ProjectsPageCoverage.test.tsx and two in ProjectsPage.test.tsx had been rewritten to open the overflow before clicking. All seven are restored to their upstream form, and website/src/test/ProjectsPage.test.tsx is now byte-identical to main as well. The one test added for this feature remains and now asserts the intended shape directly: Move is reachable in the overflow and is not a peer button.

The change's file count drops from 60 to 58.

Verification

typecheck, lint, lint:theme-colors, lint:phantom-classes, lint:restyle-ratchet, lint:i18n, i18n:check all rc=0. The locale style ratchets pass with the base ref supplied (I18N_BASE_REF=origin/main, whole src/i18n/style/ directory, 11 files / 99 tests) — last round I reported those green from a bare local run, where the [changed-values] test silently skips; that was a false green and this is the enforcing invocation. Both ProjectsPage suites: 93 passed. Mutation sweep 28/28 caught, 0 skipped. Backend flake8, the baselined black gate, docs_lint, and brand-name / comment-history / feature-map all pass with the base pinned to the merge base.

I checked the specs and docs for claims that asserted the regroup and found none to correct: docs/feature-map/README.md's row already describes Move as reached through ⋯ More actions, which is still where it is.

Items 4, 6 and 8 are still open and are the PR author's call, not mine to take unilaterally.

@timwukp

timwukp commented Sep 24, 2026

Copy link
Copy Markdown
Contributor Author

Round: Items 4 and 6 taken, and the mutation sweep now has a CI consumer (Item 8)

Pushed 41f13867b3. All three of the remaining First Principles items are addressed, and taking Item 8 found a real defect inside the sweep itself.

Item 4 — the session CLI verb is gone

The verb could only refuse, so it was command-group surface whose whole content was "not here". Removed: its registration and dispatch branch in cli.py, _session_dispatch in cli_commands.py, its COMMAND_GROUPS row in cli_help.py, its cli.md table row, and the two tests that asserted the refusal.

A deletion is not finished while something still claims the deleted thing exists, so four more claims went with it: instances.md §17.9 now states that a session move is planned from the dashboard only and there is no CLI verb; the handlers/migration.py docstring no longer says "which is why kirocrew session move refuses"; move_plan.py no longer lists it as a caller; and test_migration_move_cli.py's docstring no longer describes a verb the file does not cover.

Spec task 3.8 bundled the CLI verb with the dashboard action, so it is now split in the text: the dashboard half is done, and the CLI half of requirement 5.10 is recorded as not in this slice with the reason. test_cli_help.py::test_offered_and_grouped_sets_match — the help-drift guard — passes, which is what proves no orphan group or orphan row is left behind.

taskrun move stays: it prints a real plan, so it has an action a user can complete.

Item 6 — the Schedule status cell's inline error notice is out

The status cell is back to its upstream single-line form, and SchedulePage.tsx's diff is now nothing but the migration feature: an import, the movingJobId state, the dialog, and the onMoveToCrew wiring. The accessibility point behind it stands (a hover title is unreachable by keyboard and by a screen reader, so a failed job announced only there is announced to nobody) — it simply is not this change's business.

Removing it made two screenshots in the description show a surface that no longer exists, so they are out of the body too, along with the narration that described them. Evidence for a surface this PR does not ship is exactly the kind of misleading evidence the screenshot rounds were about. Five shots remain and each URL was re-checked as 200 image/png; the gate asks whether a visual change carries an image, which it still does.

Item 8 — wired to CI, and it caught a false verdict on its first run

The reviewer's concern was precise: the sweep's old-string anchors rot silently on a refactor. The sweep itself does fail on a rotted anchor (it reports SKIPPED (anchor not found) and exits non-zero) — what it lacked was any automated consumer, so rot waited for a human.

test/test_migration_mutation_anchors.py is that consumer. It reads the table and mutates nothing, so it costs milliseconds inside the ordinary backend suite. Four assertions: every anchor resolves exactly once (the sweep substitutes the first occurrence, so a second copy makes the mutation ambiguous), every mutation changes the line at all, every named test file exists, and every mutation is paired with the runner that can read its test.

Deliberately not a workflow change. A step in .github/** would trip the fork workflow-change guard and need a maintainer override for a test that belongs in the suite anyway.

That last assertion found a live defect. One frontend mutation — "the derived crew-lookup notice becomes undismissable again" — mutates website/src/components/MoveToCrewDialog.tsx and names a .tsx test, but was left on the default pytest runner. The sweep calls a mutation caught when its command exits non-zero, and pytest exits non-zero because it cannot collect a .tsx file. So that mutation had been reporting caught on the strength of a collection error, never having run the test that was supposed to object — a false verdict inside the tool whose whole purpose is detecting tests with no teeth.

Fixed by giving it runner="vitest", and with the correct runner the mutation is genuinely caught, so the test did have teeth and only the verdict's provenance was wrong. The guard asserts the class rather than the instance, so a frontend mutation can never again be judged by a runner that cannot read its test.

I also verified the guard discriminates rather than passing vacuously: rotting one anchor by hand made it fail naming that exact mutation, and restoring it made it pass.

Verification

Backend: 181 tests pass across the nine migration suites, the new anchor guard, test_spawn_audit, test_security_posture and test_cli_help. flake8, isort, the baselined black gate and docs_lint clean; mypy reports only cli.py's PidfdChildWatcher, a local Python 3.14 artifact absent on CI's 3.12. Black reformatted test_migration_move_cli.py after the deletion, and its footprint is confined to that docstring and the removed block.

Frontend: seven lint/type gates rc=0; the locale style ratchets pass with I18N_BASE_REF supplied (11 files / 99 tests); 149 tests across the dialog, both menus, the Schedule page and the task-run page.

Mutation sweep 28/28 caught, 0 skipped — now with every verdict coming from the runner that can actually read its test. Brand-name, comment-history and feature-map pass with the base pinned to the merge base.

The change is 59 files.

@timwukp

timwukp commented Sep 29, 2026

Copy link
Copy Markdown
Contributor Author

Rebased onto e076ee0971 (173 commits since the previous head). Now MERGEABLE; head 360bca93fa, still one commit, 60 files, no binaries.

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.

website/src/api/client.ts — the facade was split into per-domain modules under website/src/api/client/, so the three plan*Move methods this branch added to the monolithic body no longer had a place to sit. I took upstream's restructured file wholesale and moved them into a new website/src/api/client/migration.ts exporting createMigrationEndpoints, spread as ...migration.plans after ...cron.jobs to keep key order stable.

That shape is required rather than preferred: ApiClient.refactor.facade.test.ts discovers modules with import.meta.glob, asserts one endpoint factory per domain module, and asserts every api member has exactly one owning segment outside a four-entry inline allowlist. Leaving the methods inline in the facade would have failed the ownership assertion. The test passes (8/8), and it also confirms the new module is picked up by the glob.

src/kiro_crew/dashboard/handlers/__init__.py — upstream added an office_slides import block at the position this branch's migration block occupied. Both kept; migration sits in alphabetical order between messaging and office_slides, with upstream's section comment left attached to its own block. isort --check-only passes.

website/src/components/SessionActionsMenu.tsx — upstream added a CrewBoardMenuItem entry in the same array position as this branch's move-to-crew item. Both kept.

docs/request-for-change/README.md — append-only narrative; upstream added the rfc-app-sdk-crew-webview and rfc-question-card-pager entries and a rfc-wake-judge revision. Upstream's text kept in full, this branch's sentence appended. Resolved in place rather than by taking upstream's whole file, because the status-table row above it had already auto-merged.

Re-verification, not just a SHA swap. The rfc-crew-work-migration row's claims were re-checked against the new base before rebinding it to e076ee0971: git ls-tree -r --name-only origin/main | grep -c 'kiro_crew/migration' returns 0, and src/kiro_crew/dashboard/session_transfer.py still documents "Copy, never move".

Also in this push: an unused import sys removed from the mutation-sweep tool (flake8), and one history-narrating phrase rewritten to present tense in test/test_migration_mutation_anchors.py (Comment History Gate). Both were real failures on the previous head's tree, caught locally.

Verification on the rebased tree. npm ci first, since 173 upstream commits can move pinned deps.

  • Backend: 181 passed across the nine migration suites, the mutation-anchor guard, spawn audit, security posture and CLI help — same count as pre-rebase. Both ship/drop partition guards confirmed RUN and passed (asserted by node id, not by a -k filter that can silently collect nothing), so this rebase introduced no unclassified dataclass fields.
  • Backend lint: flake8, isort, the baselined black gate, docs lint all clean. mypy reports only cli.py:448 asyncio.PidfdChildWatcher, which is a local Python 3.14 artifact — that attribute was removed from asyncio in 3.14 and CI runs 3.12.
  • Diff-scoped gates with *_BASE_REF pinned to the new merge base: brand name, comment history, feature map all pass, none reporting a non-enforcing mode.
  • Frontend: lint, typecheck, theme colours, phantom classes, restyle ratchet (345 sites / 50 files, matching baseline), lint:i18n, i18n:check — all clean. Locale style ratchets run with I18N_BASE_REF=origin/main over the whole src/i18n/style/ directory: 11 files / 105 tests, zero skips.
  • Component tests: 153 passed across the dialog, both menus, the Schedule page and the task-run page.
  • Mutation sweep: 28/28 caught, nothing survived, skipped or timed out.

Screenshot evidence in the description is unaffected — the images live on a separate branch of the fork, not in this diff.

@timwukp

timwukp commented Sep 30, 2026

Copy link
Copy Markdown
Contributor Author

Rebased onto ac0c8bbf1b (99 commits since the previous head). Head is now 5d90a88481, still one commit.

One conflict, in docs/request-for-change/README.md: an append-only paragraph where upstream added the rfc-jev-task-executor and rfc-wake-judge entries. I kept upstream's text as-is and appended this PR's sentence after it. Both claims in the rfc-crew-work-migration row still hold at the new base (kiro_crew/migration paths on main: 0; dashboard/session_transfer.py still documents "Copy, never move"), so the row now cites ac0c8bbf1b.

The previous head's backend reds were test_apps_registry_coverage.py (Windows symlink loop) and test_remote_crew_chaining.py (lent hop port ownership). This diff touches neither area. The symlink fixes landed on main after the previous base, in #15081, #15065 and #14986, and this rebase picks them up. #14960, which touches instances credentials and listeners, also landed after the previous base; it may be what resolves the hop-port failure, but I have not established that. Fork PR Description failed with "could not list check-runs … refusing to POST" (an API read failure, not a template finding). The body passes pr-description-check.sh locally.

Verified on the rebased tree after npm ci:

  • Backend: 181 passed across the migration suites, spawn audit, security posture and cli_help. Both ship/drop partition guards ran and passed, so no new unclassified upstream fields.
  • Backend lint: flake8, isort, the baselined black gate and docs_lint all pass.
  • Diff-scoped gates, with the base ref set to the merge base: brand name and feature map pass, and comment history passes in enforcing mode.
  • Frontend: the seven lint and type gates pass. 31 test files / 1366 tests pass, including the ApiClient surface and facade tests and the full src/i18n/style/ ratchet run with I18N_BASE_REF.
  • Mutation sweep: 28/28 caught.

@timwukp

timwukp commented Sep 30, 2026

Copy link
Copy Markdown
Contributor Author

Status note for anyone picking this up. The PR stays open for review; it is not abandoned.

Checks on head 5d90a88481: 89 pass, 5 fail. None of the code-level checks fail: build, backend and frontend tests, lint and type checks, and the diff-scoped gates are all green. The five failures are Design Review, UX Review, GPT 5.6 Review, Opus 5 Review, and PR Readiness, which aggregates them. As described in an earlier comment, I can't act on those four reviews from the fork: their findings were never posted as comments, or they were withheld.

The branch is CONFLICTING again. It is 78 commits behind main. I'm holding the rebase until the PR is close to merging. Each rebase discards the current CI run and resets fork-workflow approval, and upstream moves fast enough that an early rebase re-conflicts within hours. When a maintainer is ready to review, I'll rebase and re-verify.

Checked before continuing: origin/main (64b0a33c9d) has no existing crew-to-crew move for cron jobs, chat sessions or task runs, so this PR does not duplicate shipped work. Three things there share the name but do something different:

  • dashboard/session_transfer.py copies a session between instances and documents "Copy, never move".
  • The cron and session "move" actions move items between folders.
  • adopt/release re-parent a session in the sidebar tree.

None of these reassigns an owning crew.

What would unblock merging:

  1. Code-owner review from kirodotdev/kirocrew-team.
  2. Visibility into the Design, UX, GPT 5.6 and Opus 5 findings (a redacted summary would be enough), or a decision to treat them as advisory.

Copy link
Copy Markdown
Contributor

PR triage (automated, REST-only audit at origin/main af1eb612da): REBASE + CONTINUE-DEVELOPMENT. Not a duplicate, not superseded.

@timwukp

timwukp commented Oct 6, 2026

Copy link
Copy Markdown
Contributor Author

Thanks @bolichen97 for the triage. I've addressed both findings, rebased onto e281ecaf33, and pushed. The head is now 285931eec3, still a single commit.

The two defects

  • Session-existence oracle (handlers/migration.py): when a slot is missing, the handler now returns the shared slot_not_found(), the same body a foreign slot gets from the ownership check. A new test, test_a_missing_slot_and_a_foreign_slot_answer_the_same_404, asserts that the two responses are byte-identical and that neither one names the slot. The test failed against the old code before I made the fix.
  • status: [] TypeError (taskrun_adapter.py): every status read goes through _status_str, and _status_str now raises MalformedRunRecord when it gets a list, a mapping or a number. The CLI already catches that error on all three of its paths. The new parametrized tests cover [], {} and 3, on both the progress-description path and the mid-run refusal path. They reproduced the bare TypeError first.

Rebase notes

  • Upstream moved route registration into server_runtime/mcp_routes.py. The cron and task-run /move routes now live there, and this PR no longer touches dashboard/server.py.
  • I changed the route-wiring test to register routes on a fresh application and read the router, instead of grepping source. Deleting a route makes it fail.
  • test_the_mcp_route_table_keeps_its_rows_and_order needed new frozen values, 232 → 234 rows. With this PR's two /move rows removed, the table hashes back to the previous digest e2d49d27…, so those two rows are the only change to the table.
  • The checks you asked for both pass. Both ship/drop partition guards (CronJob and Project) ran, so no new unclassified fields. The session-move tests pass alongside test_slot_ownership_checkpoint.py, which covers the fix(apps): enforce app slot ownership on every per-slot route #16212 middleware.

Verified locally

  • Backend: 545 tests passed.
  • Lint: flake8, isort, and pinned black 26.3.1 over all 28 Python files in the diff. mypy is clean apart from the existing asyncio.PidfdChildWatcher line. That line only appears on Python 3.14, and CI runs 3.12.
  • Diff-scoped gates: comment history, brand name and feature map, with the base ref set.
  • Frontend: all seven lint and type gates pass, plus 33 test files / 1403 tests, including the src/i18n/style/ ratchets with I18N_BASE_REF.
  • Mutation sweep: 28/28 caught.

Thanks also for pointing out that rfc-durable-run-coordinator is superseded. Any task-run slice that actually performs a move will build on taskq instead.

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.
@timwukp

timwukp commented Oct 6, 2026

Copy link
Copy Markdown
Contributor Author

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 cf208434af, rebased onto 222ada5184 and still a single commit. It fixes the two narrow GPT 6.1 findings:

  • F1, preview leaks the Layer B snapshot (handlers/migration.py). Every session preview now calls release_bundle_files on every exit path. The release is in a finally around planning, plus a release inside _build_session_bundle when the ledger read fails after the snapshot was taken. Three new tests check that the snapshot file is gone after a successful preview, after planning raises, and after the ledger read raises. All three failed on the old code first.
  • F3, long identities are clipped at 320px (MoveToCrewDialog.tsx). Requirement identities and finding keys now carry break-all, and finding text carries break-words. A new test renders a long script-path identity and a long finding key.

Not in this push, waiting on direction from #7577.

  • GPT F2, the header has four actions. An earlier round restored Chat, Discard, Schedule and Restart as peer buttons, following the First Principles review. max-two-buttons-per-row is a blocking rule, so that has to be reversed. I'll fold it into the reshape rather than flip it back on its own.
  • First Principles. The review proposes removing handoff_id / bundle_version and dropping the CLI verbs, the duplicate cron_move.py and redactor, and the .kiro/specs copy. That matches the split I proposed on Seamlessly migrate a live session, task-runner run, and schedule from one crew to another #7577, so I'd like a maintainer's answer there before cutting.
  • Design and UX. Both say no screenshots reached them, although the description links five images and Screenshot Evidence passes. I haven't worked out why yet. Design's naming point is also open: should the preview routes and verbs be named …/move/plan?

Two other checks.

  • Sensitive Change Review. It fails because the diff touches src/kiro_crew/security_posture.py. That file has to change: each new redaction sink must be registered, or test_security_posture.py fails. The gate states that a fork PR cannot pass it, so merging this needs a maintainer to take it over on a branch of this repository.
  • Backend Lint & Type Check (3.12). On the previous head it was cancelled during mypy after 25 minutes. On main the same job takes about 18. Locally mypy is clean except for the existing asyncio.PidfdChildWatcher line, which only appears on Python 3.14.

Verified on the rebased tree.

  • Backend: 553 passed, including both ship/drop partition guards and the slot-ownership checkpoint.
  • Lint: flake8, isort and pinned black are clean.
  • Diff-scoped gates: comment history, brand name and feature map pass.
  • Frontend: the seven lint and type gates pass, plus 1404 tests, including the src/i18n/style/ ratchets with I18N_BASE_REF set.
  • Mutation sweep: 28/28 caught.

@iamwhatever

Copy link
Copy Markdown
Contributor

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.

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

Labels

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

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants