Skip to content

fix(acp): spell a Crew agent's tools in KAS ids so the kas backend can read files - #13375

Closed
billygerhard wants to merge 1 commit into
kirodotdev:mainfrom
billygerhard:fix/kas-tools-projection
Closed

billygerhard wants to merge 1 commit into
kirodotdev:mainfrom
billygerhard:fix/kas-tools-projection

Conversation

@billygerhard

@billygerhard billygerhard commented Sep 24, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: An agent spec written in kiro-cli tool names gives the kas backend's agent the same file-reading, listing and searching tools it has on kiro-cli, governed by the same operator rules.

Set agent.acp_backend to kas and every new chat runs read-blind. The agent can run a shell command and write a file, but it has no tool to read a file, list a directory, or search — it shells out with cat and grep for every read. Asked to read a file without the shell, a live KAS session on the shipped spec answers: "I don't have a dedicated file-reading tool available in this environment."

Why it matters

The kas switch is offered in Settings (Developer mode) and crew-member DM sessions default to it. On that engine the shipped agent loses most of its file surface silently: no error, no warning, just a model that cannot read. Reads through the shell also bypass the read-only auto-approve path, so a --approval reads gateway prompts for what should have been free.

Not a goal

  • Mapping KAS display titles (model-influenceable prose) onto tool identities; only engine-stamped identity is read.
  • Mounting delete_file in the shipped agent spec; it mounts only when a spec names it, and this PR only makes a mounted one governable.
  • Changing what kiro-cli's own gate path sees. ONE new mechanism is gated on the ACP_BACKENDS_PERMISSION_KIND_FROM_TOOL_CALL membership set (KAS only): the permission-frame kind carry-over; on a kiro-cli session a tool_call frame stays kindless -- pinned in test_tool_call_classification.py (test_the_membership_gate_is_what_keeps_a_kiro_cli_edit_kindless, test_a_kiro_cli_search_stays_kindless_and_read_only_proven). The other mechanisms are keyed on what the frame carries, not on the backend. The identity read takes _meta.kiro.toolId / _meta.kiro.mcpTool.identity off a permission frame (and _meta.kiro.serverName off a tool_call); kiro-cli stamps toolName / mcpServerName instead, so its request still reads through the first identity channel (test_a_kiro_cli_frame_still_reads_through_the_first_channel). The alias fold (GateFacts.policy_alias_names, the governance alias group) and the read-only proof's alias step (_is_host_read_only_builtin) read the provenance-trusted stamped tool id with an empty server name, so any harness whose _meta identity channel stamps a bare KAS id (read_file, run_command, delete_file) gets the fold. They are a no-op on kiro-cli because no name kiro-cli stamps on its own built-ins (fs_read, execute_bash, ..., or its read/write/shell spellings) is a key of the policy table -- pinned in test_tool_names.py::TestPolicyAliases::test_no_name_kiro_cli_stamps_on_its_own_built_ins_is_a_policy_key.
  • Re-measuring the KAS vocabulary automatically on an engine bump; kirocrew doctor reports drift, and the fixture's note says how to re-measure.

Backwards compatibility

Not a pure superset: the kas backend's gate changes in four user-visible ways. Three hunks are shared by every harness, not KAS-only: _AndRuleset.permits/resolve in platform/governance.py now query the inner ruleset even when the outer one refuses, so a composed decision carries explicit_deny provenance (an outer allow-miss no longer hides an inner explicit deny); gate_decision resolves an alias group as OR across spellings within one layer and intersection across layers (any explicit deny on any spelling is final, pinned per layer by TestGateDecisionAliasGroups::test_an_allow_on_the_kas_id_never_outvotes_a_same_layer_deny_on_the_kiro_cli_name); and "targetFile" joins TARGET_PATH_KEYS in platform/tool_paths.py. On kiro-cli the alias groups are empty and no kiro-cli tool spells its target as targetFile, so these hunks change no kiro-cli decision; they are cross-harness code, and a reviewer should read them as such.

New refusals on KAS

  • A delete_file of a write-protected config (config.json, cloud.json, the trust roots) is DENIED, where before the delete kind routed through no gate at all. Only when a spec mounts delete_file; the shipped spec does not.
  • A delete_file whose targetFile is still relative after ~/env expansion (../config.json) is DENIED as unverifiable, because the sensitive-path resolvers would judge it against the gateway CWD rather than the file the engine deletes. Edits keep judging relative params paths as before. The engine spells its write paths absolute (measured), so this does not fire on a real KAS write.
  • A KAS built-in is now governed under its kiro-cli policy name too: auto_deny_tools: ["fs_read"] denies a KAS read_file/grep_search/list_directory, ["fs_write"] denies str_replace/fs_append/delete_file, ["execute_bash"] denies run_command. Before, a kiro-cli-spelled deny did not bind on KAS at all. An operator who relied on that gap sees new denies.

New admissions on KAS

  • An allow-mode tools ceiling or governance profile written in kiro-cli names (fs_write) now admits the KAS spelling of the same work (str_replace, fs_append) through the alias group, where before the raw KAS id was refused for not being listed. This is the intended fix (the ceiling binds to the tool the operator meant), and it is the one place the change permits more. delete_file is excluded from that admission (POLICY_ALIAS_DENY_ONLY_IDS): a fs_write grant never becomes a deletion grant.
  • A KAS read_file/grep_search/list_directory is auto-approved under --approval reads exactly where kiro-cli's fs_read is, because the read-only proof now reads the KAS id under its kiro-cli name.

Unchanged: the KAS tools / excludedTools wire lists are supersets of what was sent before, every added id is refused auto-approval and prompts, edits are judged exactly as before on every backend, and gate_decision's other callers see no alias_groups.

Per reader of the changed seams:

  • Reader: hooks.on_tool_call write-protected tier (is_edit_call) — a KAS delete_file of a config file is now DENIED where before the delete kind routed nowhere; an edit is judged exactly as before. Pinned: test_hooks_edit_gate_diff_path.py::TestADeleteIsOnTheWritePlane.
  • Reader: platform.governance.classify_tool_args (is_edit_call) — a delete's target now joins the filesystem.write set an ALLOW-mode confinement judges, instead of reaching it pathless; edits unchanged. Pinned in test_governance_policy.py.
  • Reader: decisions/points/tool_risk.py — moved to is_workspace_edit_call so the caution-badge carve-out stays edit-only and a delete keeps its badge; an edit's badge behaviour is unchanged. Pinned in test_decisions_tool_risk.py.
  • Reader: gate_decision — its three other callers (governance.py MCP probe, cli_commands.py, and every profile resolution without aliases) pass no alias_groups / deny_aliases and evaluate exactly as on main; only hooks._governance_denial passes them, for a KAS built-in whose id has a kiro-cli policy spelling. An outer refusal on any harness reports the same explicit_deny it did; the inner half is now asked too, which only ADDS a reason, never flips a verdict (test_governance_policy.py::TestGateDecisionAliasGroups).
  • Reader: the spec-hook matcher (agent_sdk/spec_hooks.py via kas_tool_match_names / KAS_TOOL_MATCH_VOCABULARY) and withhold_hook_gated_auto_approval — KAS_TOOL_IDS_BY_KIRO_TOOL is now DERIVED from the policy table plus the hook-only rows instead of hand-written; its rows are set-equal to main's (main already carried execute_bash → run_command; only the fs_write tuple's order differs, and kas_tool_match_names sorts), so every matcher meets the same calls. Pinned: test_spec_hook_kas_tool_names.py.
  • Reader: cli_doctor — a new advisory row; no verdict changes.

What changed (motivation → approach → change)

Crew writes one agent spec, src/kiro_crew/config/defaults.json, in kiro-cli's tool vocabulary: fs_read, fs_write, grep, glob, code. _project_tools in src/kiro_crew/acp/kas_agents.py sent that list to KAS as written. KAS matches an allowlist entry against a tool's exact id or a tag and translates nothing. On KAS, fs_read and fs_write are policy capabilities, not tool ids, and grep / glob are no tool at all. So only the names both engines share mounted: execute_bash, fs_write, code, web_fetch, plus the MCP refs.

One table, both directions. src/kiro_crew/platform/tool_names.py holds the two vocabularies, pinned to a recorded registry of the engine's built-in ids (test/fixtures/kas_builtin_tool_ids.json: engine commit, kiro-cli version, the two id spaces KAS has, and the ACP kind each built-in stamps). It is the ONE kiro-cli <-> KAS table: the spec-hook matcher vocabulary in src/kiro_crew/acp/kas_permissions.py (KAS_TOOL_IDS_BY_KIRO_TOOL), which used to hand-keep the same rows, is now derived from this module's policy table (its inverse grouped per kiro-cli name, plus the three hook-only rows -- web_fetch, web_search, use_subagent -- and the shared fs_write id), with a test asserting the two agree pair for pair. The projection carries each kiro-cli built-in with its KAS family beside it: fs_read → read_file, list_directory; grep → grep_search; glob → file_search; fs_write → str_replace, fs_append. A mount family stops at what the kiro-cli tool can do, so delete_file mounts only when a spec names it; an excludedTools entry has the opposite polarity and reaches everything governed under the name, so excluding fs_write also excludes delete_file. Nothing on the kiro-cli path changes.

The gate reads the table the other way. An operator's auto_deny_tools or a tools-scope ceiling is written in kiro-cli names, so on_tool_call in src/kiro_crew/hooks.py evaluates a KAS built-in under its kiro-cli name too, in three places: the deny tier (both spellings, since a deny only denies), the tools-scope ceiling (the raw KAS id and its kiro-cli name travel as ONE identity with two spellings, gate_decision's new alias_groups: an explicit deny on either spelling binds -- read from a new Decision.explicit_deny provenance flag that ScopedRuleset.permits sets on a deny-mode match and that _AndRuleset.permits and resolve carry through every fold, with an outer allow-mode miss still consulting the inner half so a composed central+local ceiling or a profile extends cannot hide a subordinate tier's deny behind an authority's allow -- otherwise the group is judged per level, a level permitting any spelling and the identity admitted when every governing level does, so a ceiling granting str_replace beneath a profile granting fs_write admits the one tool both granted -- governance profiles are written in kiro-cli vocabulary and an allow-mode profile requires every queried item to match, so asking the raw id beside the alias would refuse a permitted write for an entry no operator wrote, while asking the alias alone would let a deny-mode deny: [str_replace] stop binding), and the read-only auto-approve classifier (_is_host_read_only_builtin) so a KAS read is free under --approval reads exactly where fs_read is. One alias may only deny (POLICY_ALIAS_DENY_ONLY_IDS, split by policy_alias_split): delete_file reads under fs_write so a write deny reaches it, but kiro-cli's fs_write cannot delete -- the same line the mount table draws -- so an allow-mode tools: ["fs_write"] written for kiro-cli must not become a deletion grant on KAS; the delete is asked on its own name and fs_write travels in gate_decision's deny_aliases, consulted for an explicit deny only, never a permit. fs_write binds str_replace / fs_append / delete_file, execute_bash binds the shell's permission id run_command. Only for built-ins: KAS names an MCP server on the tool_call as _meta.kiro.serverName and the tool on the permission request as _meta.kiro.mcpTool.identity, both read by src/kiro_crew/acp/_dispatch.py, so an MCP server's own read_file is seen as a served call and left alone. The request's identity.serverName is never adopted as the call's server: the trust flag records the tool_call's cache hit, and a built-in's tool_call writes that hit with an empty server, so a server taken from the request would carry trust into the server-keyed grants (the app-own MCP auto-approve) for a built-in -- agreement with the cached server is a no-op, and a server the tool_call did not name is ignored. A built-in stamps only _meta.kiro.toolId, read as the tool name when the preceding tool_call wrote the identity cache with an empty name (the id fills that blank, and is not read on a request no tool_call preceded, such as a sub-agent spawn, whose identity comes from the consent classifier alone); it adds a deny target and cannot satisfy a trust-gated grant. The toolId passes _harness_identifier, the one length-and-spelling bound (128 characters, identifier characters only) that _permission_tool_id already applied, so an oversized or glob-shaped id is read as absent; the mcpTool.identity pair is read as the strings the harness wrote, like every other identity channel. The fold reads that identity and nothing else: the display title is the model's own description, so a shell call described as str_replace folds to execute_bash, not fs_write, and a deny fs_write never refuses a command the operator did not name.

src/kiro_crew/cli_doctor.py adds a KAS-block row that reports ✅ only when the installed kiro-cli is one of the releases the tables were verified on (KAS_TOOL_IDS_VERIFIED_ON_KIRO_CLI, pinned equal to the fixture's verified_kiro_cli_versions: 2.24.0, where the id tables were first read; 2.24.1, where the write-plane path shapes were measured and the ids re-checked; and 2.27.1, the current release and the first above this repo's 2.27.0 kiro-cli floor, where every table was re-read against the extracted KAS bundle), and warns (advisory) for a release newer than the latest, older than the earliest, or between two verified ones and itself never measured -- a list, not an exact pin, and the fixture's engine-bump note now ends with the step that maintains it (re-measure, then append the release to verified_kiro_cli_versions), which the doctor row names: the policy direction fails permissive on an id a newer engine may have renamed, and an older engine was never measured, so it is unverified rather than compatible. The .github/black-baseline.txt entries for test/test_cli_doctor.py and test/test_governance_policy.py are pruned: the added test classes made each file fully black-clean, so the ratchet graduates them.

A delete is on the write plane. WRITE_PLANE_KINDS in src/kiro_crew/platform/tool_paths.py adds the ACP delete kind beside edit in the routing predicate the hook gate, the always-enforced tier (src/kiro_crew/llm_helpers.py) and governance share, and targetFile joins TARGET_PATH_KEYS, so a delete_file of the crew config.json is refused by the same write-protected-config hard deny an edit is, and a delete of an SSH key by the sensitive-path keystone. KAS's targetFile is workspace-relative in its schema's terms, and the sensitive-path resolvers anchor a relative input to the gateway process CWD, so {"targetFile": "../config.json"} judged there would be a verdict about a different file from the one the engine deletes; edit_target_candidates therefore withholds a params path that is still relative after ~/env expansion and marks the union unanchored (the flag the diff-block path already set, which the hook gate, the always-enforced tier and governance each hard-deny as unverifiable) -- but ONLY for the kinds in PARAMS_ONLY_TARGET_KINDS (delete): a delete carries no diff block, so its one params spelling is the call's whole target, while an edit also names its file in the diff block and its params spellings are judged verbatim as they always were, so an ordinary relative file_path on an edit is not refused on any backend. The kind is read off the ACP kind the consumer routed on (the hook gate's tool_kind, the always-enforced tier's event.tool_kind, governance's tool_kind), never off the backend. That rule is also moot in practice on the kas write plane because the engine spells its write paths absolute: measured live (kiro-cli 2.24.1, engine 076b7d57b) through this PR's projection of the shipped spec, a fs_write create, a str_replace edit and a fs_append all completed under the carry-over with rawInput.path absolute (<workspace>/<file>), and a delete_file (spec extended to name it) put an absolute targetFile on its frame -- recorded per write tool as tool_call_path_shape in the fixture, matching the tools' own schema text ("Absolute path to the file"). A trusted delete gains the target gate and keeps its scan (it has no document body to suppress). The tool.risk caution-badge carve-out (src/kiro_crew/decisions/points/tool_risk.py) read the same predicate and would have dropped the badge on every delete; it now reads is_workspace_edit_call, the edit-only sibling added beside is_edit_call, so a delete_file keeps its caution badge on the auto-approving sessions where the badge is the only signal (docs/system-specs/modules/decisions.md updated). The route has to be reachable from the wire, and on KAS it was not: KAS's request_permission names no kind (its toolCall is id, status and title), so every KAS call reached the gate's kind-keyed tiers as "". build_permission_event now takes the kind the preceding tool_call frame carried, from a tool_kind_cache written by _build_tool_call_event beside the params/shell/identity/diff-path caches (src/kiro_crew/acp/_dispatch.py), owned and cleared per turn by AcpSessionHandle beside its siblings -- and it retains only a WRITE-PLANE kind (edit/delete). The engine's kind map (mapActionTypeToToolKind) stamps search on grep_search, file_search and list_directory and other on code/tool_search, recorded per built-in as tool_call_kind in test/fixtures/kas_builtin_tool_ids.json, and a carried search would veto the host read-only proof that auto-approves a KAS search by identity, so every other kind is not written and the event stays "" as before. Real classifications only, and a kind the permission frame does state is never overridden; a non-string kind on the frame (an unvalidated harness value) is read as absent rather than stamped, and both write-plane predicates and the always-enforced tier's delete route test membership only on a string, so an unhashable kind classifies instead of raising and aborting the turn. The cache is handed to the wire parsers per frame (AcpSessionHandle._tool_kind_cache_for_wire) only for members of a new capability set ACP_BACKENDS_PERMISSION_KIND_FROM_TOOL_CALL (src/kiro_crew/agent_sdk/backends.py, KAS only; re-exported via acp/types.py and acp_backends.py, classified off-card in backend_cards.py); the handle's construction is identical for every harness, and a non-member is handed None, which disables both writer and reader: kiro-cli's permission frames omit kind too, but it routes edits by the diff content block already and its kindless governance classification is additive, so a carried edit would change what its gate sees. The kiro-cli path (AcpClient and the non-member handle) is unchanged. The owning spec docs/system-specs/modules/security.md records the write-plane kinds, the delete route, and the carry-over.

flowchart LR
  subgraph Before
    a1[spec: fs_read, grep, glob]:::ctx --> a2[KAS matcher: exact id or tag]:::ctx --> a3[nothing mounted]:::removed
  end
  subgraph After
    b1[spec: fs_read, grep, glob, fs_write]:::ctx --> b2[tool_names: expand]:::added --> b3[read_file, list_directory, grep_search, file_search, str_replace, fs_append]:::added --> b4[KAS mounts them]:::changed
    b4 --> b5[permission frame _meta.kiro.toolId]:::added --> b6[gate: policy_aliases]:::added --> b7[deny / ceiling evaluated under the kiro-cli name too]:::changed
  end
  classDef added fill:#DCFCE7,stroke:#16A34A
  classDef changed fill:#FEF3C7,stroke:#D97706
  classDef removed fill:#FEE2E2,stroke:#DC2626,stroke-dasharray:4 3
  classDef ctx fill:#E0F2FE,stroke:#0284C7
Loading

🟩 added · 🟨 changed · 🟥 removed · 🟦 unchanged

The spec's kiro-cli names arrive at KAS with the ids KAS registers, and a rule written in kiro-cli names still binds to them.

The tools row in src/kiro_crew/docs/agent-spec-fields.md records the expansion and the exclusion polarity.

Tests

  • test/test_tool_names.py — the two tables agree; delete_file is governed as a write but mounted by no family; the shell's run_command is governed as execute_bash; the exclusion reading withholds delete_file under fs_write and equals the gate's policy table per owner name (execute_bash included) less the permission-frame-only run_command, which the engine's exclusion matcher cannot see and whose registered owner already withholds; every mounted id is in the recorded engine registry, every policy key is an id the gate can receive, and every registered filesystem/shell id has a policy spelling or is listed as shared; the runtime's measured-version constant equals the fixture's; policy_aliases dedupes and never echoes an input; policy_alias_split files a same-capability alias (str_replace, read_file, run_command) as admitting and delete_file's as deny-only, and the deny-only set equals exactly the policy keys outside every mount family; expand is pure and order-preserving.
  • test/test_hooks.py::TestClassifierOnlyHostTrustedProof — a trusted KAS read built-in is proven read-only under its kiro-cli name (auto-approved under --approval reads); a KAS write/shell alias is not; a KAS read of a sensitive path is still denied first; the fold still demands trust and no server.
  • test/test_tool_call_classification.py::TestKasMcpServedIdentity — a KAS MCP-served read_file (server on the tool_call as serverName, the pair on the permission request as mcpTool.identity) reads as a server call, so a built-in fs_read deny does not bind and the read-only proof does not fire, while a @probefs/read_file rule does bind; a kiro-cli mcpServerName frame still reads through the first channel; a malformed (non-string) server/tool half reads as absent, and a 129/300/512-character MCP tool name keeps its exact @server/<name> deny binding against a title-keyed auto_approve_tools grant.
  • test/test_cli_doctor.py::TestTheKasBlockReportsToolVocabularyDrift — the measured engine is reported matching; a newer one and an older one each warn and name both versions (advisory, no issue; older is unverified, not compatible); an unknown version is its own row.
  • test/test_tool_call_classification.py::TestKasPermissionFrameTakesTheToolCallKind — a KAS permission frame (no kind, toolId only) carries the tool_call's kind for edit/delete and NOT for read/search/execute/fetch/other; the carried set is exactly the write plane and the fixture's per-built-in tool_call_kind map agrees (search on all three search-shaped reads, read on read_file); a KAS grep_search/file_search/list_directory whose tool_call stamped search still auto-approves under the read-only proof with the cache present; without the cache the kind is "" (the pre-fix shape); a kind the frame states is not overridden; a non-string frame kind is read as absent (the cached kind fills it, or "" without one); placeholders are not cached; the cache retains only the closed write-plane vocabulary (a 1 MiB kind and every non-write kind retain nothing; the stored values are the edit/delete literals); end to end from the wire, a KAS delete_file of ~/.kiro/crew/config.json is denied by the hook tier and the same frame without the carry-over is not, and a delete_file naming ../config.json, ../.kiro/crew/config.json or notes/plan.md is denied as a relative target (a delete carries no diff block, so its relative params path is the unverifiable whole target). TestTheKindCarryOverIsKasOnly — the KAS handle hands its cache to the wire and every other backend's handle (and a runtime double with no backend) hands None, with the attribute constructed identically on all; a kiro-cli search tool_call followed by a kindless permission frame stays kindless and read-only-proven both without the cache (the kiro path) and with it (the reader withholds search); a kiro-cli edit tool_call is what the membership gate keeps kindless (the reader would carry it).
  • test/test_decisions_tool_risk.py — a delete-kind call at caution 0.99 under a trust policy still records its badge (a deletion is not the workspace edit the carve-out describes). test/test_hooks_edit_gate_diff_path.py — is_edit_call and is_workspace_edit_call differ only on delete and agree on every other kind/diff-path pair; WRITE_PLANE_KINDS == {edit, delete}.
  • test/test_kas_agents.py::TestTheSpecIsSpelledInKasToolIds — each kiro-cli read tool carries its KAS family; the write family stops at str_replace, fs_append and projects no fs_write allow rule; delete_file mounts only when named; the spec's own name is kept; shared names and @refs pass through unchanged; a spec already in KAS ids is not duplicated; excluding fs_write also excludes delete_file; the table names only registered ids (from the fixture).
  • test/test_kas_agents.py — TestToolsFailClosed pins the mixed spec's projection to its exact list; TestAgainstTheRealBundledSpec pins the shipped defaults.json projection exactly to expand_kiro_cli_tool_names(spec["tools"]), with the read family present and delete_file absent.
  • test/test_hooks.py::TestKasAliasesAreGovernedUnderTheirKiroCliName — auto_deny_tools: ["fs_write"] denies str_replace, fs_append, delete_file by engine-stamped identity; a model-authored title spelling a KAS id never folds, and an identified shell call (run_command / execute_bash) titled str_replace is not refused by a write rule but is by a shell rule; fs_read / grep / glob rules deny their KAS read aliases; the governance tools scope is asked str_replace and fs_write as one alias group (also when the title is the raw id), and through the real gate_decision an allow-mode profile of {title, fs_write} permits the KAS write, a deny-mode profile denying either spelling refuses it, and a raw-id auto_deny_tools still binds; a KAS delete_file is asked on its own name with fs_write deny-only (no alias group), and through the real gate an allow-mode {title, fs_write} refuses the delete while admitting str_replace, naming delete_file admits it, and a deny under fs_write refuses it; test/test_governance_policy.py::TestGateDecisionAliasGroups — allow-mode in either vocabulary admits, neither spelling listed refuses naming the kiro-cli name, deny-mode on either spelling binds with rule1-deny, a ceiling deny on the raw id is final, a subordinate deny folded under an allow ceiling (either fold order) still binds and answers the same as a single-tier ceiling, a central delete_file deny folded with a local fs_write allow (either order) refuses the delete on its own name, an allow-mode fs_write grant does not admit the delete (an allow-set miss, not a written deny), an allow set naming delete_file admits it without naming fs_write, a deny under the deny-only alias binds, a sibling verb's deny does not reach it, and a permitted deny-only alias never admits; deny provenance survives every fold while an allow-mode miss never gains it, a title equal to a group member is covered by the group, empty groups are ignored, each level granting a different spelling admits the one tool (either way round), a level granting neither spelling still refuses, and a profile deny is reported over a ceiling allow-miss; a shared name gains no alias and is not asked twice; an MCP-served read_file / str_replace gains no alias at either tier while a @filesystem/read_file rule still binds.
  • test/test_hooks.py — a sensitive path under targetFile is denied like the other spellings; a KAS delete_file on an AWS credentials path is denied; an ordinary targetFile is still allowed.
  • test/test_hooks_edit_gate_diff_path.py::TestADeleteIsOnTheWritePlane — a delete of config.json / cloud.json / playwright-cli-config.json is denied by the write-protected tier; an ordinary delete passes; a delete naming no target is denied; the read allowance is untouched. TestADiffBlockRoutesOntoTheWritePlane — a non-string kind (list, dict, number, None) classifies as "not on the plane by kind" in both readings instead of raising, and a diff block still routes it. TestARelativeParamsPathIsUnverifiableOnlyWhereItIsTheWholeTarget — a relative targetFile on a delete, alone or beside a safe absolute one, is denied by the hook gate and the always-enforced tier as a relative target and an absolute one is judged on its merits; a relative path/file_path on an ordinary edit is NOT refused by either tier; a relative diff-block path is still denied whatever the params say; a ~-spelled delete target stays anchored; edit_target_candidates withholds the relative spelling and sets unanchored for the delete kind only (PARAMS_ONLY_TARGET_KINDS == {"delete"}) and judges it verbatim for edit and for an unknown kind; governance emits the never-permittable marker for a delete and the verbatim path for an edit. test/test_cli.py::TestChatPermissionRequest — through the production direct-client parser and the CLI consumer, a trusted edit of an absolute path and a trusted edit of a relative one each reach the human and are approved (the relative edit is the routine shape on every backend); the cache-miss pin now names an absolute inline path so what it asserts is provenance (unverified_shell), not a target denial.
  • test/test_spec_hook_kas_tool_names.py::test_the_hook_rows_are_the_gate_s_policy_table_inverted — every policy-table pair appears in the hook matcher rows and every row entry outside the hook-only tools is a policy-table pair (plus the shared fs_write id).
  • test/test_llm_helpers_edit_gate.py::TestADeleteIsGatedOnItsTarget — the always-enforced tier refuses a trusted delete of config.json, allows an ordinary one, does not target-gate an untrusted frame on its own word, and still runs the scan on a delete.
  • test/test_llm_helpers_mcp_document_body_real_frames.py::TestKasReadsTheSameBarFromItsOwnFrames — on captured kiro-cli 2.27.1 KAS frames, a resident knowledge_add_document call reaches the document-body exemption on the pair the permission frame states and the tool_call's server confirms (approved; the pre-PR pin had this fail-closed because no KAS identity was parsed); a deferred call's nested body keeps the full scan (denied); a request naming a server the tool_call did not is denied; a benign body is approved in both modes.
  • test/test_tool_call_classification.py::TestKasPermissionFrameCarriesTheBuiltinId — a KAS permission frame's _meta.kiro.toolId becomes the event's tool name; a cached toolName wins over it; malformed ids are ignored (non-strings, blanks, one over the 128-character bound, a 100 KiB id, a glob, whitespace), the bound is exactly _permission_tool_id's, and a malformed mcpTool.identity field reads as absent (the cached server and the toolId stand); a frame no tool_call preceded (a sub-agent spawn's synthetic toolCallId) is not named by its raw id -- the consent classifier's verified Crew name or nothing -- and a built-in id with no preceding tool_call is not named either; the frame id cannot satisfy the spawn rung or the identified-MCP-call reader; end to end, auto_deny_tools: ["fs_read"] denies a KAS Read File permission from the frame alone. test/fixtures/acp_frames/kas/session.expected.json re-recorded for the same reason.
  • test/test_kas_mode_binding.py — the injected agent's wire tools list carries the family beside fs_read.

Mutation-probed: emptying the mount table fails 8; re-adding delete_file to the fs_write family fails 3; removing the deny-tier alias fold fails 8; feeding the title back into the fold fails 2 and also dropping its identity guard fails 5; removing the governance alias fold fails 1; appending the alias beside the raw id in the governance query (requiring every spelling) fails 4; dropping the explicit-deny short-circuit in the alias group (alias-only semantics) fails 4; hiding the inner half's deny behind an outer allow-miss fails 2; resolving each spelling through the intersection instead of per level fails 3; emptying the deny-only alias set (routing delete_file through the admitting group) fails 4; letting the deny-only channel refuse on an allow-set miss fails 2; dropping the mcpServerName guard fails 2; using the mount reading for excludedTools fails 1; emitting permission-frame-only ids in exclusions fails 2; disabling the permission-frame id read fails 5; reading the frame id on a request no tool_call preceded fails 10; reverting WRITE_PLANE_KINDS to edit only fails 5; dropping run_command from the policy table fails 2; removing the read-only classifier alias fold fails 5; removing the KAS serverName identity channel fails 1; neutralizing the mcpTool identity read fails 1; disabling the doctor newer-engine warning fails 1; restoring <= in the doctor row fails 1; comparing drift against the single first-measured release instead of the verified list fails 3; disabling the permission-frame kind carry-over fails 5; caching the unknown placeholder fails 1; handing the kind cache to every backend's wire fails 4; routing a delete into the caution-badge carve-out fails 1; stamping a non-string frame kind on the event fails 5; testing write-plane membership without the string guard fails 3; appending a delete's relative params path to the target set instead of withholding it (emptying PARAMS_ONLY_TARGET_KINDS) fails 5; retaining every non-placeholder kind in the cache instead of the write-plane vocabulary fails 8; dropping delete_file from the derived hook rows fails 1; reading the frame toolId with a plain strip instead of the identifier bound fails 5.

Manual verification

Live hands-test against the real engine (kiro-cli acp --agent-engine v3 --auth-method cli, kiro-cli 2.24.0, the kas backend's own argv), driven over stdio with the shipped defaults.json projected through to_client_custom_agent, injected as a client custom agent, activated, then prompted to read a file using a file-reading tool and not the shell:

spec sent as (main) spec projected (this PR)
tools on the wire execute_bash, fs_read, fs_write, code, grep, glob, … … fs_read, read_file, list_directory, fs_write, str_replace, fs_append, … grep, grep_search, glob, file_search, …
tool_call frames on the read turn 🟥 none 🟩 Read File, kind read, rawInput.path = the file
agent reply 🟥 "I don't have a dedicated file-reading tool available in this environment. The tools I have are shell execution, file writing, web fetch, and skill activation." 🟩 hello-from-kas-probe (the file's contents)
asked to delete_file a path under .ssh/ — 🟩 no tool call, file untouched (delete_file is not mounted by fs_write)

Both JSON reports are posted as a PR comment.

The per-built-in ACP kind recorded in the fixture was read from the engine source at the measured commit (packages/kiro-agent/src/acp/session-update-utils.ts mapActionTypeToToolKind, keyed by each tool file's actionType): list_directory stamps search, not other, which is why the carry is confined to the write plane rather than to "everything but search on the two grep-shaped tools".

Write-plane hands-test (kiro-cli 2.24.1, same argv, this PR's projection of the shipped spec, a fresh workspace, every permission answered allow): "create probe-created.txt" → Write File (fs_write, kind edit, rawInput.path absolute) and the file exists; "replace alpha with alpha-edited in probe-note.txt" → Read File then Replace in File (str_replace, kind edit, absolute path) and the line is edited; "append gamma" → Append to File (fs_append, kind edit, absolute path) and the line is appended; "delete probe-victim.txt" with the spec as shipped → no tool call, file untouched (not mounted); with delete_file added to the spec → Delete File (delete_file, kind delete, absolute targetFile) and the file is gone. Every permission frame carried _meta.kiro.toolId and no kind. Recorded per write tool as tool_call_path_shape in the fixture.

Re-measured on kiro-cli 2.27.1 (the extracted KAS bundle kiro-cli runs, @kiro/agent 0.66.22, read directly rather than through a live model turn): every registered id is present and none is renamed; the shell's static id is still run_command; the actionType → ACP-kind switch is byte-identical to the 2.24.1 bundle's for every kind the fixture records; each built-in's permission request still stamps _meta.kiro.toolId with its own class id; and the path-parameter descriptions that produced the absolute shapes are unchanged. 2.27.1 is appended to verified_kiro_cli_versions (and the pinned constant), with the reading recorded under the fixture's remeasured key. 2.27.0 was not measured and stays unverified.

Related Issues

no linked issue: found while hands-testing the kas backend; no open issue reports it.

Pattern harvest

Rule candidate: review-prompt
Pattern: a spec or policy written in one engine's tool vocabulary is applied to another engine's allowlist or name-keyed gate without translation; check the target engine's matcher when a backend switch is added, and translate in both directions (mount AND govern).

Checklist

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

@billygerhard
billygerhard requested review from a team and chenmingwei23 September 24, 2026 14:10
@billygerhard

Copy link
Copy Markdown
Contributor Author

Intent: A Crew agent spec written in kiro-cli's tool vocabulary mounts the equivalent read/list/search/edit tools when the session runs on the KAS backend, so agent.acp_backend=kas no longer runs read-blind.
Not a goal: Granting any capability the kiro-cli spelling did not already grant (no deletion from fs_write), changing the kiro-cli path, or changing what is auto-approved on either engine.

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention fork Pull request from a fork (external contributor) readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Sep 24, 2026
@billygerhard
billygerhard force-pushed the fix/kas-tools-projection branch from f0a94bb to 85d5210 Compare September 24, 2026 15:00
@github-actions

github-actions Bot commented Sep 24, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Opus 5.5, fork) — 🟡 CONCERNS

Design-level review of 733b6880d1b459384b7ef08f8525c92621d7760c via the fork AI-review pipeline — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

Design-Verdict: CONCERNS

This one PR changes how governance is judged for every harness (alias groups in gate_decision, provenance in _AndRuleset/resolve) and adds a new delete_file gate, all under a title about mounting KAS read tools.

Watch

  • Cross-harness and new-surface changes are bundled with the mount fix. The fix itself is the change to kas_agents._project_tools/excludedTools. Two pieces are tied to it: the alias fold and the KAS serverName identity channel. Without them, the newly mounted tools would escape rules spelled in kiro-cli names. Two other pieces are not tied to it. The delete-kind write-plane routing, targetFile in TARGET_PATH_KEYS and the permission-kind carry govern a tool that, per the description, "the shipped spec does not" mount. The _AndRuleset provenance change runs on every harness. So a revert of the read-tools fix also reverts a security gate and a change to shared evaluator semantics, and review attention on the fix is spread across both.
    Clears when: the delete_file governance (kind carry, WRITE_PLANE_KINDS delete, targetFile, relative-delete refusal) moves to its own PR or commit, or the description says why the mount fix cannot ship safely without it.
  • A kiro-cli version bump makes the policy direction fail permissive, and only an advisory row warns about it. KIRO_CLI_NAME_BY_KAS_TOOL is hand-pinned to one fixture. If KAS renames a built-in or drops the _meta.kiro.serverName stamp, two things happen: a deny written as fs_read stops binding, and an MCP tool named read_file could be read as a built-in by the read-only auto-approve proof. Today kirocrew doctor only warns.
    Clears when: on a release outside KAS_TOOL_IDS_VERIFIED_ON_KIRO_CLI, the alias fold and the read-only proof are withheld (fail closed), or the description records why advisory-only is acceptable.

[DESIGN-REVIEWED] 733b688

Description read

[DESCRIPTION-READ] 04007b91c4c35e408da69ae50bfcc86a3bff024b532d8345b86585493be062e3

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

@github-actions

github-actions Bot commented Sep 24, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Opus 5.5, fork) — 🟡 CONCERNS

Premise-level review of 733b6880d1b459384b7ef08f8525c92621d7760c via the fork AI-review pipeline — why this exists and whether the shipped surface is the smallest honest version. Updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

First-Principles-Verdict: CONCERNS

A separate delete_file fix rides along inside the read-tools fix, about half the security-gate surface, though the Goal excludes deletion and the shipped spec never mounts it.

Not justified as shipped

  • Item 6 — oversized: the Goal covers "file-reading, listing and searching tools", and Not-a-goal says the shipped spec does not mount delete_file. A spec naming delete_file already mounted it on base, because KAS matches exact ids. So this gap predates the PR and is fixed independently of the read fix. It adds: WRITE_PLANE_KINDS, PARAMS_ONLY_TARGET_KINDS, _is_anchored/ntpath, targetFile, tool_kind_cache, ACP_BACKENDS_PERMISSION_KIND_FROM_TOOL_CALL, _tool_kind_cache_for_wire, _trusted_delete, is_workspace_edit_call, deny_aliases and POLICY_ALIAS_DENY_ONLY_IDS. deny_aliases is a generalized tuple parameter with one consumer (gate_tiers) and one entry (delete_file).
    Subtraction: move the delete write-plane routing and the kind carry-over into their own PR. Keep only the excludedTools widening to delete_file here.
    Clears when: the delete routing is removed from this PR, or a human amends the Goal.
  • Item 8 — rides along, inherited: "may rename, add or lack a built-in" is a guess, not an observed drift. KAS_TOOL_IDS_VERIFIED_ON_KIRO_CLI warns on every new kiro-cli release until someone adds that release to it by hand. test_tool_names.py already pins the tables to the recorded fixture.
    Subtraction: delete _report_kas_tool_vocabulary, kas_vocabulary_drift, kas_verified_releases and the version tuple.
    Clears when: a reported KAS rename that the fixture pin missed is linked, or the row is removed.

What this change ships

Inventory (8 items) — 6 justified

Intent: let a Crew agent on the kas backend read, list and search files the way it does on kiro-cli, under the same operator rules — FIX.

  1. KAS agents now get read_file/list_directory/grep_search/file_search/str_replace/fs_append from kiro-cli tool names — justified
  2. Excluding fs_read/fs_write on KAS also excludes their KAS ids, delete_file included — justified
  3. auto_deny_tools written in kiro-cli names now denies the matching KAS ids — justified
  4. Allow-mode ceilings and profiles written in kiro-cli names admit KAS spellings, and governance now reports a deny from either layer of a composed ruleset — justified
  5. KAS reads are auto-approved under --approval reads — justified
  6. KAS delete_file of a protected config or a relative path is refused, using the kind carried over from the tool_call frame — oversized: a separate, pre-existing delete gap
  7. A KAS MCP server's read_file is no longer treated as a built-in (new serverName identity channel) — justified
  8. kirocrew doctor prints a KAS tool-vocabulary drift row — rides along; inherited

[FIRST-PRINCIPLES-REVIEWED] 733b688

Description read

[DESCRIPTION-READ] a4d4ee3fa706addd754e7f3e65b6f70202acd519a0c0262e9f33b14271163d39

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

@github-actions

github-actions Bot commented Sep 24, 2026 •

Copy link
Copy Markdown
Contributor

GPT 6.1 Review (fork) — ✅ no blocking findings

Reviewed 733b6880d1b459384b7ef08f8525c92621d7760c via the fork AI-review pipeline; updated in place on each push.

Review details

No findings.
[GPT-REVIEWED] 733b688

@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 24, 2026
@github-actions

github-actions Bot commented Sep 24, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5.5 Review (fork) — ✅ no blocking findings

Reviewed 23b653231c1b47c5cc34ecd6d679a1d4da696329 via the fork AI-review pipeline; updated in place on each push.

Review details

No findings.

[OPUS-REVIEWED] 23b6532

@billygerhard

Copy link
Copy Markdown
Contributor Author

Live KAS hands-test evidence

Real engine: kiro-cli acp --agent-engine v3 --auth-method cli (kiro-cli 2.24.0). The shipped defaults.json (MCP refs stripped, no servers in the probe) projected through to_client_custom_agent, injected via _meta.kiro.customAgents, activated with session/set_mode, then one session/prompt asking for a non-shell file read. Recorded off the wire by a stdlib probe; the scratch paths are the probe workdir.

main behaviour (spec names sent verbatim)

{
  "mode": "verbatim",
  "agent_tools_sent": [
    "execute_bash",
    "fs_read",
    "fs_write",
    "code",
    "grep",
    "glob",
    "web_fetch",
    "web_search",
    "introspect",
    "session",
    "report",
    "tool_search"
  ],
  "available_modes_include_probe": true,
  "builtin_tag_classes_mounted": [
    "read",
    "shell",
    "web",
    "write"
  ],
  "read_turn_stop": "end_turn",
  "read_turn_tool_calls": [],
  "read_turn_reply": "I don't have a dedicated file-reading tool available in this environment. The tools I have are shell execution, file writing, web fetch, and skill activation. Reading the file would require the shell, which you asked me not to use.\n\nWant me to read it with the shell instead?"
}

this PR (projected)

{
  "mode": "fixed",
  "agent_tools_sent": [
    "execute_bash",
    "fs_read",
    "read_file",
    "list_directory",
    "fs_write",
    "str_replace",
    "fs_append",
    "code",
    "grep",
    "grep_search",
    "glob",
    "file_search",
    "web_fetch",
    "web_search",
    "introspect",
    "session",
    "report",
    "tool_search"
  ],
  "available_modes_include_probe": true,
  "builtin_tag_classes_mounted": [
    "read",
    "shell",
    "web",
    "write"
  ],
  "read_turn_stop": "end_turn",
  "read_turn_tool_calls": [
    {
      "title": "Read File",
      "kind": "read",
      "rawInput": {
        "path": "/local/home/wilgerh/.kiro/crew/scratch/runtime-46d1d8f2/probe/work-fixed/probe-note.txt",
        "offset": null,
        "limit": null
      },
      "toolCallId": "toolu_bdrk_016rhF3M4bxN1MsdrBWLkbyL"
    }
  ],
  "read_turn_reply": "hello-from-kas-probe",
  "delete_turn_tool_calls": [],
  "delete_permission_frames": [],
  "delete_turn_stop": "end_turn",
  "victim_still_exists": true
}

@billygerhard
billygerhard force-pushed the fix/kas-tools-projection branch from 85d5210 to 79f02c2 Compare September 24, 2026 15:59
@billygerhard

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: platform/tool_names.py holds the mount table and its inverse; hooks.on_tool_call folds a KAS id to its kiro-cli name for the deny tier and the governance tools scope

  • KAS write aliases bypass tool-name security policy — fixed in 79f02c2

Legitimate: the projection mounted str_replace/fs_append under a spec's fs_write while auto_deny_tools and the tools-scope ceiling match on the kiro-cli name, so a trust mode ran the denied write.
Fix: policy_aliases() maps every KAS id the projection can mount (plus delete_file) back to its kiro-cli name; on_tool_call appends those to deny_targets and to the governance extra_titles, read from both the trusted identity and the title (a deny target can only deny).
Pinned by test_hooks.py::TestKasAliasesAreGovernedUnderTheirKiroCliName (deny tier: fs_write→str_replace/fs_append/delete_file, fs_read/grep/glob→read aliases, title-only path; governance: fs_write asked for a str_replace call). Mutation-probed: removing the deny fold fails 8, removing the governance fold fails 1.

@billygerhard

Copy link
Copy Markdown
Contributor Author
  • Unverified provider vocabulary, declared "Manual verification: N/A" — fixed in 79f02c2

Hands-tested against the real engine (kiro-cli 2.24.0 acp --agent-engine v3): the shipped spec projected through to_client_custom_agent, injected as a client custom agent and activated. Read turn produced a Read File (kind read) tool_call and returned the file's contents; the verbatim control produced no tool_call and the agent stated it had no file-reading tool. A delete_file request on a .ssh/ path produced no tool call and left the file (not mounted by fs_write).
Both wire reports are in the PR comment above the dispositions; the body's Manual verification section now carries the before/after table.

@billygerhard

Copy link
Copy Markdown
Contributor Author
  • Stamp the table with the KAS/kiro-cli version it was read from — fixed in 79f02c2

platform/tool_names.py now records the measurement: kiro-agent (KAS) at kiro-cli 2.23.1, with the source files each id was read from (tools/default/*.ts, acp-tool-factories.ts createAcpFsTools) and what a future rename looks like on the kas backend. The live probe above confirms the same ids on 2.24.0.

@billygerhard

Copy link
Copy Markdown
Contributor Author
  • Unverified platform claim: every test asserts Crew's own projection, not what KAS mounts — fixed in 79f02c2

Confirmed on the real engine: with the projected spec KAS ran Read File (kind read) and returned the file; with the verbatim spec it ran nothing and said it had no file-reading tool. Wire reports for both runs are in the evidence comment; the body's Manual verification section carries the table.
delete_file is not mounted by fs_write in this PR, so the targetFile observation is pinned at the gate instead (test_hooks.py: a KAS delete of ~/.aws/credentials under targetFile is denied) and the field name is read from tools/delete-file.ts; the live delete request produced no tool call, as intended.

@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Sep 24, 2026
@github-actions

github-actions Bot commented Sep 24, 2026 •

Copy link
Copy Markdown
Contributor

Security Scope Review (fork) — 🟡 CONCERNS

Which legitimate operations does 733b6880d1b459384b7ef08f8525c92621d7760c newly refuse? Model proposes, scripts/deny_diff.py decides — updated in place on each push. A script-confirmed regression blocks PR readiness.

the reviewer's own judgement; no confirmed regression

Scope-Verdict: CONCERNS

TIGHTENING: write-plane routing now treats the ACP delete kind as a write, and KAS's delete_file is the tool that sends it. Its targetFile argument is now read as a target path, and a relative path or (on Windows) a drive-less path is refused as unverifiable -- the ONE threat it refuses is a KAS delete_file of a write-protected Crew config. Quoted from platform/tool_paths.py: +WRITE_PLANE_KINDS: frozenset[str] = frozenset({"edit", "delete"}) / +TARGET_PATH_KEYS: tuple[str, ...] = ("path", "file_path", "filePath", "targetFile") / "before this, delete_file {"targetFile": "~/.kiro/crew/config.json"} declared a kind neither gate routed and the always-on config hard-deny never ran." Two supporting changes come with it:

  • Alias fold: a KAS id is also asked under its kiro-cli name (policy_alias_names in hook_runtime/gate_tiers.py, alias_groups/deny_aliases in platform/governance.py).
  • Kind carry-over: a KAS permission request takes the edit/delete kind from its earlier tool_call frame (_dispatch.build_permission_event).

ADJUDICATED: 15 candidates, 0 confirmed newly-refused

PLATFORM COVERAGE:

  • posix: config read, relative workspace rm, greps naming targetFile / delete_file / str_replace / fs_write, the fixture read, a crew-home listing and the POSIX test run. They probe whether any shell tier picked up the new vocabulary or the config-path focus. The shell tiers (security/, hooks.SHELL_DENY_TIERS) are untouched by the diff.
  • windows: %USERPROFILE% config read, del and Remove-Item on a relative backslash path with no drive letter, a Select-String vocabulary search and the .venv\Scripts\python.exe test run. They cover the one Windows-specific assumption the diff adds: _is_anchored requires ntpath.splitdrive to find a drive or UNC share.
  • any: kirocrew doctor, kiro-cli --version, git rm --cached. These are platform-neutral strings next to the new doctor row and the new delete routing.
  • Not covered: the Windows drive-anchoring rule only acts on non-shell write targets, so no shell row can reach it. See UNADJUDICATED.

UNADJUDICATED:

  • Write-protected-config / edit-target gate on the non-shell write plane (llm_helpers._resolve_permission → _edit_target_denial(_gated_params, event.diff_path, event.tool_kind) → tool_paths.edit_target_candidates(..., tool_kind=) → _is_anchored; and gate_tiers._tier_write_protected → the same function). Inputs I would have submitted, each of which is a legitimate operation:
    • KAS delete_file {"targetFile": "<abs-workspace>/build/out.txt"} with kind delete (must stay allowed).
    • KAS delete_file {"targetFile": "build/out.txt"} (relative). This is now refused as unanchored. Whether the engine always sends absolute paths is unmeasured, and if it ever sends a workspace-relative path, every ordinary KAS delete is lost.
    • On Windows, an edit whose diff-block path is \repo\src\x.py (rooted, no drive letter). Before, os.path.isabs accepted it; now _is_anchored refuses it because the drive is missing. This applies on every backend, not only KAS, because the diff-path branch of edit_target_candidates now uses _is_anchored too. So a Windows backend that sends drive-less rooted diff paths loses every edit. I cannot demonstrate a backend that sends this shape, so this is a CONCERNS item, not a BLOCK.
  • targetFile added to TARGET_PATH_KEYS. It is read by target_paths, which feeds the sensitive-path keystone for every non-shell tool, not just delete_file. An MCP tool whose argument is named targetFile and points at a readable-but-sensitive-tier path (for example a ~/.kiro/crew/... leaf) is now newly path-judged. I would have submitted an MCP {"targetFile": "<workspace>/docs/page.md"} call (must stay allowed).
  • Governance alias groups (_tier_governance → _governance_denial → gate_decision(alias_groups=, deny_aliases=), with explicit_deny now propagated through _AndRuleset.permits / resolve). I would have submitted:
    • A KAS read_file under an allow-mode profile tools: ["fs_read"] (must stay admitted).
    • A KAS delete_file under an allow-mode tools: ["fs_write", "delete_file"] (must stay admitted).
    • A kiro-cli fs_write under a ceiling whose allow-mode miss now also queries the profile for its deny (must be unchanged).
  • Deny-rules alias fold (GateFacts.deny_targets + policy_alias_names). An operator's auto_deny_tools: ["execute_bash"] now also refuses KAS run_command, and ["fs_write"] refuses str_replace / fs_append / delete_file. That is intended, but it means a KAS agent whose operator denied fs_write loses str_replace and delete_file, which it had before. This depends on tool identity, not command text, so the shell classifier cannot reach it.
  • Kind carry-over (AcpSessionHandle._tool_kind_cache_for_wire → build_permission_event(tool_kind_cache=)): a KAS permission event now has edit/delete where it used to have "", which sends every KAS edit through the edit-target gate. I would have submitted a KAS str_replace on a relative workspace file with a diff block (must stay allowed).

[SCOPE-REVIEWED] 733b688

Security scope review -- adjudicated candidates

  • macos-latest (platform posix): 10 classified, 0 newly refused, 10 still allowed.
  • ubuntu-latest (platform posix): 10 classified, 0 newly refused, 10 still allowed.
  • windows-latest (platform windows): 8 classified, 0 newly refused, 8 still allowed.

No candidate flipped from allowed to refused.

@billygerhard
billygerhard force-pushed the fix/kas-tools-projection branch from 79f02c2 to c3d667e Compare September 24, 2026 16:21
@billygerhard

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: the policy-alias fold in hooks.on_tool_call is gated on an empty mcp_server_name

  • KAS aliases incorrectly widen denials to MCP tools — fixed in c3d667e

Legitimate: the reference MCP filesystem server names its tools read_file/list_directory, and the fold applied a built-in fs_read deny to them.
Fix: policy_aliases runs only when mcp_server_name is empty; kiro-cli stamps mcpServerName on every MCP-served call, so an MCP call keeps exactly the deny/governance targets it had before.
Pinned: an MCP-served read_file under a fs_read deny is not denied; an MCP-served str_replace under a fs_write ceiling is not asked fs_write; a @filesystem/read_file rule still binds. Mutation (guard removed) fails 2.

@billygerhard

Copy link
Copy Markdown
Contributor Author
  • excludedTools uses the mount-bounded expansion, so excluding fs_write leaves delete_file mounted — fixed in c3d667e

The two directions now have their own reading: expand_kiro_cli_tool_names (mount, bounded by the kiro-cli tool's verbs) and expand_kiro_cli_tool_exclusions (exclusion, everything governed under the name, i.e. the inverse of the gate's policy table). Excluding fs_write now excludes str_replace, fs_append and delete_file.
Pinned in test_kas_agents.py (excluding fs_write also excludes delete_file) and test_tool_names.py (exclusion reading equals the gate's policy table per name). Mutation (mount reading for excludedTools) fails 1.

@billygerhard

Copy link
Copy Markdown
Contributor Author
  • Zero consumers of the kas_agents re-export of KAS_TOOL_FAMILY_BY_KIRO_CLI_NAME — fixed in c3d667e

The re-export and its # noqa: F401 are deleted; kas_agents imports only the two expanders it calls, and the tests import the table from platform.tool_names, where it lives.

@billygerhard

Copy link
Copy Markdown
Contributor Author
  • targetFile in TARGET_PATH_KEYS rides along; not needed to fix read-blindness — rebutted

This PR is the change that makes delete_file a documented, reachable mount on KAS: the tools row now tells a spec author to name delete_file to get it, and the policy table governs it as fs_write. Before this PR nothing in Crew named delete_file at all; a spec that mounted it did so by accident. Publishing the mount path without the keystone reading its one argument would ship a sensitive-path hole with a manual.
Same PR, same mechanism (one vocabulary, both directions: mount, govern, and read the path the governed tool carries), one line plus its tests. Splitting it into a follow-up would leave the window open between the two merges for exactly the readers this PR sends to delete_file.

@iamwhatever

Copy link
Copy Markdown
Contributor

Reviewed, not approving (crew-pr-reviewer). Very large (+6202/-202), and it changes how agent tool permissions are spelled for the kas backend. It needs a maintainer and a security owner.

@bolichen97

Copy link
Copy Markdown
Contributor

Reviewed on the maintainers' behalf (sweep 2026-10-06): every src/ hunk read; kiro-cli/claude/codex/goose paths verified unchanged, the KAS-only tightens accepted as bypass-closing, and the PR's 17 test files pass on the merge tree. Because this fork PR touches src/kiro_crew/hooks.py, the Sensitive Change Review gate cannot be cleared on a fork, so per that policy I have taken it over on an in-repo branch: #17280 carries your head 5fbf2f6 verbatim with you as co-author. I will close this PR once #17280 merges.

@billygerhard

Copy link
Copy Markdown
Contributor Author

Rebased onto main at 781294256f as 0d9b1d0bb6 (one commit, same change) -- the previous head conflicted with #17192, which moved the tool gate into hook_runtime/gate_tiers.py.

What moved, and nothing else changed in behaviour:

  • ToolCall gains identity_unreadable (from AcpEvent.mcp_identity_unreadable), carried through from_event / kwargs and the on_tool_call shim; _tier_unverifiable_shell refuses it beside the unrecoverable-shell deny.
  • The KAS-id -> kiro-cli policy-name fold is GateFacts.policy_alias_names, read by deny_targets (deny tier) and by _tier_governance (alias_groups / deny_aliases, policy_alias_split), exactly as the two inline blocks did.
  • _tier_write_protected passes tool_kind to edit_target_candidates.
  • The in-flight liveness bound now lives on the shared InFlightToolTracker (max_calls, evicted), which AcpSessionHandle constructs with MAX_ACTIVE_TOOL_CALLS and keys by _liveness_key; _no_tool_in_flight reads the tracker's mark. The sub-agent's tracker keeps the default (no bound), as on main.

Local: the PR's 17 test files + test_gate_tiers, test_deny_diff, test_security_conductor_verify_fix, test_name_grant, test_gate_crash_fail_closed, test_hooks_composition_contract and every test_subagent* file -- 5132 passed, 0 failed; black (baselined gate), isort, flake8, mypy clean on the touched modules.

#17280 carries the pre-refactor head; this one is ready to be re-taken if that is still the route.

@github-actions

github-actions Bot commented Oct 7, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Opus 5.5, fork) — ⏭️ skipped

Revision 733b6880d1b459384b7ef08f8525c92621d7760c touches no user-facing surface (no changes under website/ or committed screenshots), so the UX review was skipped. Advisory — does not block merge.

@billygerhard

Copy link
Copy Markdown
Contributor Author

Rebased 0d9b1d0bb6 -> 289abb54fe onto main at caf10f90f4 to clear a two-line import conflict in acp/runtime.py (#17629 and this PR both add an import at the same spot; both kept). No other change; 3555 local tests green, black/isort/flake8/mypy clean.

@billygerhard

Copy link
Copy Markdown
Contributor Author

Rebased 289abb54fe -> 037260d163 onto main at 4e9ca20e10 to clear the merge conflict. Two resolutions: platform/tool_paths.py keeps the new apply_patch envelope walk (#17945) and applies it before the tool_kind params filter this PR adds; docs/system-specs/modules/security.md keeps the new apply_patch paragraph and the MCP_DOCUMENT_BODY_FIELDS phrase beside this PR's delete-gate and KAS identity text. No behaviour change otherwise. Locally: 3056 tests green across this PR's test files plus the tool_paths/edit-gate tests; black, isort, flake8, mypy clean.

@billygerhard

billygerhard commented Oct 8, 2026 •

Copy link
Copy Markdown
Contributor Author

Rebased 037260d163 -> 0f2632c79f onto main at f9a07ab3fa, no conflicts, no code change. The shard-1 red on 037260d163 (test_crew_recency.py, four cron_creator_refusal AttributeErrors) was inherited from the base commit dbf2ae3519 and is fixed on current main; the Opus and Security Scope check-runs ended "review incomplete" / "no leg reported" without a verdict, so this push re-runs them. Locally: 3075 tests green on the touched files, black/isort/flake8/mypy clean.

@billygerhard

Copy link
Copy Markdown
Contributor Author

Pushed 0f2632c79f -> fa2fdcb46c (rebased onto main at 791b10a68e). This head REMOVES the four mechanisms the First Principles review listed as riding along with the fix, and the description is updated to match:

  • the liveness-map bounds (ToolCallState.__post_init__ cuts, InFlightToolTracker(max_calls)/evicted, MAX_ACTIVE_TOOL_CALLS, _liveness_key, _no_tool_in_flight) -- acp/liveness.py and the handle are back to main for this;
  • the provenance-cache admission (admit_tool_call_cache_entry, the overflow record, _refuse_unretained_provenance, _release_settled_tool_call);
  • the 512-character MCP-name refusal (mcp_identity_unreadable and its three refusal sites; tool_surface.py back to main);
  • the once-per-version KAS vocabulary drift warning at session start (_warn_kas_vocabulary_drift, _kas_drift_version, _KAS_DRIFT_*; acp/runtime.py back to main). kirocrew doctor keeps its advisory row.

What stays is the fix itself: the KAS tool-id projection, the kiro-cli-name alias fold for denies and tools ceilings, the read-only proof under --approval reads, the derived spec-hook table, the write-plane delete gate with the KAS kind carry, and the KAS MCP identity read. Diff shrinks from 74 files / +6307 to 39 files / +3280. Locally: 2982 tests green on this PR's test files, 4872 green on the wider acp set; black, isort, flake8, mypy clean.

@billygerhard

Copy link
Copy Markdown
Contributor Author

Pushed fa2fdcb46c -> 11647dc05e: text only. The doctor row and two comments in platform/tool_names.py / test_tool_names.py still described the session-start drift warning removed on the previous head (First Principles item 8); the sentences are gone. No code-path change; test_cli_doctor.py + test_tool_names.py 311 green, black/flake8 clean.

@iamwhatever

Copy link
Copy Markdown
Contributor

This maps a Crew agent's tool names to KAS built-in ids so the kas backend can read, list and search files. It also changes the governance and permission evaluation: alias_groups in gate_decision, tool_names.py and tool_paths.py, delete_file routed as a write through the protected-config gate, and doctor checks. HOLD because it is a fork PR of about 1,100 production lines (3,275 total) that changes the security policy and governance evaluator, and Sensitive Change Review is red on head 11647dc. All three whole-design and scope lanes report CONCERNS. The Design Review says the "never permits more" compatibility claim is false, because the new alias groups admit a call when each governing level permits some spelling, which loosens allow-mode ceilings. Security Scope reports new refusals (a relative-path delete_file, KAS ids governed under kiro-cli names) that users would need to be told about. First Principles says the delete_file write-plane routing is outside the stated goal. These need a maintainer security review, an accurate Backwards compatibility section, and ideally splitting the delete_file routing into its own PR. — crew-pr-reviewer

@billygerhard

Copy link
Copy Markdown
Contributor Author

Rebased 11647dc05e -> 636110dbf0 onto main at 57c32486c2 to clear the merge conflict from #18092 (apply_patch header reading). Two text-only resolutions: the TargetPaths.unanchored docstring in platform/tool_paths.py and the edit-gate paragraph in docs/system-specs/modules/security.md now carry both the apply_patch header sentences and this PR's write-plane/delete wording. No code-path change. Locally: 3002 tests green on this PR's test files; black, isort, flake8, mypy clean.

@iamwhatever

Copy link
Copy Markdown
Contributor

This PR projects a Crew agent's tool names into KAS ids so the kas backend can read, list and search files. Along the way it changes governance composition, the deny tiers and permission resolution. I am holding for four reasons. The Sensitive Change Review check is red on the current head 636110d. The diff (~3,276 lines, ~950 production lines) touches security policy in platform/governance.py, hook_runtime/gate_tiers.py, decisions/points/tool_risk.py and llm_helpers._resolve_permission. Three current-head lanes are CONCERNS. And the Design lane notes the body's "kiro-cli path is untouched" is not true: the _AndRuleset.permits/resolve change, the new alias_groups composition (OR across spellings within a layer, then intersection across layers) and TARGET_PATH_KEYS += "targetFile" apply to every harness. The specific risk I would want a security owner to rule on: OR-ing alias spellings within one layer must never let a rule that allows the KAS id outvote a deny written against the kiro-cli name in that same layer. Alongside the explicit_deny provenance, that needs a direct test per layer. First Principles also asks to split the delete_file write-plane routing (WRITE_PLANE_KINDS delete, tool_kind_cache, _trusted_delete) into its own PR, since the shipped spec never mounts delete_file. I agree, because it makes both halves reviewable. — crew-pr-reviewer

@iamwhatever iamwhatever left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

Deep re-review of a held PR. Not yet: GitHub shows a merge conflict (CONFLICTING / DIRTY) on head 636110d, and the Sensitive Change Review check is red. The goal is real: on the kas backend the shipped agent can't read files and falls back to shell cat/grep, which also skips read-only auto-approve. But the fix changes shared governance (_AndRuleset.permits/resolve, the alias_groups composition, TARGET_PATH_KEYS += "targetFile"), and that code runs on every harness, so the "kiro-cli path is untouched" claim is not true. Attack to settle before approval: in one layer, an allow on the KAS id and a deny on the kiro-cli name. OR-ing spellings inside a layer must never let the allow outvote the deny, and I found no test that pins that per layer. Security Scope, Design and First Principles are all CONCERNS on the current head. The hold reason still stands. Requested change: Rebase onto main. Add one test per governance layer: deny "fs_read" plus allow "read_file" in the same layer means KAS read_file is DENIED. Rewrite the Backwards compatibility section to list the alias loosening of allow-mode ceilings as a change that affects every harness. Move the delete_file write-plane routing (WRITE_PLANE_KINDS delete, tool_kind_cache, _trusted_delete) into its own PR. On the owner decision: Split out delete_file, since the shipped spec never mounts it. Keep the read/list/search alias fix here, after the security owner rules on deny-beats-allow inside a layer. Risk: high. — crew-pr-reviewer

@billygerhard

Copy link
Copy Markdown
Contributor Author

Pushed 636110dbf0 -> 36f30bad5b (rebased onto main a098d44d9a).

  • Merge conflict cleared: fix(acp): fail a codex turn that ended on a provider error #18331 (codex terminal-error backend set) and fix(hooks): prove kiro-cli's read built-in read-only on the side chat #18275 (kiro-cli read -> fs_read alias) landed on main beside this PR's ACP_BACKENDS_PERMISSION_KIND_FROM_TOOL_CALL set and KAS policy-alias fold. Both kept: _is_host_read_only_builtin resolves main's alias table first, then this PR's KAS fold; the deny-rules targets and the governance identity carry main's (mcp_tool, alias) pair, and the KAS alias group replaces that pair only when an admitting alias applies.
  • New test for the same-layer question raised above: TestGateDecisionAliasGroups::test_an_allow_on_the_kas_id_never_outvotes_a_same_layer_deny_on_the_kiro_cli_name, parametrized over the policy and profile layers and both fold orders. An allow-mode set naming str_replace composed with deny: [fs_write] in the same layer denies with explicit_deny=True; a control assertion shows the same call is permitted without the alias group. Mutation-probed: dropping the explicit-deny short-circuit in the alias-group walk fails all four cases.
  • Body: the "kiro-cli path is untouched" sentence is replaced with a statement of the three cross-harness hunks (_AndRuleset.permits/resolve provenance, per-layer alias-group OR then cross-layer intersection, targetFile in TARGET_PATH_KEYS) and why they change no kiro-cli decision.

Locally: 3050 green across this PR's test files plus test_hooks.py, test_governance_policy.py, test_llm_helpers_tool_gate.py; the 6 test_cli_doctor.py reds under -n 2 are the known cross-file flake and pass 286/286 in isolation. black gate, isort, flake8, mypy clean. The delete_file split is still under discussion with the author.

@billygerhard

Copy link
Copy Markdown
Contributor Author

Re-rolled 36f30bad5b -> 1b68a3c5f5: identical patch (same patch-id), rebased onto main fecd092b19. Reason: the only non-fork-gate red on 36f30bad5b was E2E (stub ACP backend, offline), failing on session-tags-e2e.spec.ts > sidebar tag columns passing only on a Playwright retry against the zero-flaky ceiling; this PR changes no file under website/, so the spec is unrelated to the diff. Everything else on that head: 89 green, Sensitive Change Review red as on every fork head, all six AI lanes clean or advisory.

@billygerhard

Copy link
Copy Markdown
Contributor Author

Re-rolled 1b68a3c5f5 -> 7f74e7fc70: identical patch (same patch-id), rebased onto main 7044e7550b. On 1b68a3c5f5 the non-fork-gate reds were all runner-side: Frontend Tests (1) failed one vitest case (InlineMarkdownPlugin caret position, 12624/12625 passed; this PR changes nothing under website/), which turned Frontend Coverage Merge and Coverage Gate red downstream, and Backend Lint & Type Check (3.12) was cancelled mid-mypy after 25 minutes. The same patch passed all four on 36f30bad5b. All six AI lanes on 1b68a3c5f5: GPT and Opus clean, FP/Design/Security-Scope CONCERNS (advisory), UX skipped.

@billygerhard

Copy link
Copy Markdown
Contributor Author

Re-rolled 7f74e7fc70 -> a013c5eadc: identical patch (same patch-id), rebased onto main 67c1304b06. On 7f74e7fc70 the only non-fork-gate row that was not green was Backend Lint & Type Check (3.12), cancelled at the 25-minute job timeout (the black step alone ran 15 minutes on that runner); the same patch passed that job on 36f30bad5b. 89 checks green otherwise; all six AI lanes clean or advisory.

@billygerhard

Copy link
Copy Markdown
Contributor Author

Pushed a013c5eadc -> 3b5de7c3ce (rebased onto main 31430f0cc5), addressing three items from the 2026-10-09 review on #17280 that apply to this head too:

  • Windows anchoring: _is_anchored (platform/tool_paths.py) now requires a drive letter or UNC share on Windows, so a drive-relative \foo delete target is withheld as unanchored instead of passing isabs. Pinned by TestAnUnanchoredDiffBlockPathIsDenied::test_a_driveless_windows_path_is_unanchored (runs on every host by swapping in ntpath); dropping the splitdrive check fails it.
  • The one widening is now named in _tier_governance's docstring (a Reader: paragraph): an allow-mode ["fs_write"] profile/ceiling admits a KAS str_replace/fs_append that main refused under its raw id; everywhere else the fold only adds deny targets.
  • Body claim corrected: only the permission-frame kind carry-over is gated on ACP_BACKENDS_PERMISSION_KIND_FROM_TOOL_CALL. The alias fold and the read-only proof's alias step are keyed on the provenance-trusted stamped id with an empty server name, so any harness stamping a bare KAS id gets them; they are a no-op on kiro-cli because none of its stamped built-in names is a policy-table key, now pinned by TestPolicyAliases::test_no_name_kiro_cli_stamps_on_its_own_built_ins_is_a_policy_key.

Identical change otherwise. 3056 passed locally on the PR's test files (-n 2), gates clean.

@billygerhard

Copy link
Copy Markdown
Contributor Author

Pushed 3b5de7c3ce -> c030425aef (rebased onto main e5a354a0ec). The new Windows anchoring rule (a drive-relative \foo is not anchored) was correct but the two edit-gate test files spell their fixtures POSIX-rooted (/tmp/a), which the Windows runner now reads as drive-relative: 13 reds on Backend Tests (Windows) (8) in test_hooks_edit_gate_diff_path.py. Both files (test_hooks_edit_gate_diff_path.py, test_llm_helpers_edit_gate.py) now pin the anchoring path module to posixpath in an autouse fixture, since their subject is the gate rather than the path grammar; the one Windows-rule test still swaps in ntpath itself. No src/ change. Verified by forcing ntpath on Linux: the 27 simulated reds across these two files go to 0, and 3056 pass on the PR's test files.

@billygerhard

Copy link
Copy Markdown
Contributor Author

Pushed c030425aef -> 19217aafbf (rebased onto main 4eae0e125b): SAST flagged the two new autouse fixtures for patching through the shared monkeypatch (kirocrew.test-autouse-shared-monkeypatch); they now request _floor_monkeypatch per the repo rule. Test-only, 121/121 on both files plain and under forced ntpath.

@billygerhard

Copy link
Copy Markdown
Contributor Author

Pushed 19217aafbf -> 23b653231c (rebased onto main 6032176f11). Windows shard 8 still had 6 reds in test_hooks_edit_gate_diff_path.py: the posixpath pin fixed the /tmp/a fixtures but posixpath.expanduser reads HOME, which the Windows runner spells C:\Users\..., so ~/.kiro/crew/config.json stayed unexpanded and was denied as relative instead of as write-protected. Both edit-gate suites now pin _is_anchored to a small env-free POSIX grammar (test/edit_gate_anchoring_helpers.py, per the *_helpers.py convention) whose ~ expands to a fixed home. Test-only; 121/121 plain and under forced ntpath; verified the shim anchors ~/... with HOME unset.

…n read files

Crew's agent spec is written in kiro-cli's tool vocabulary (fs_read, grep,
glob, fs_write). KAS matches an allowlist entry against a tool's exact id
and translates nothing, and on KAS fs_read/fs_write are policy capabilities
rather than tool ids, so a stock spec projected verbatim mounted only the
names shared by both engines: no read, list or search tool at all. Every
chat on agent.acp_backend=kas ran read-blind and shelled out for reads.

platform/tool_names.py holds the two engines' vocabularies as one table
read in both directions, pinned to a recorded registry of the engine's
built-in ids (test/fixtures/kas_builtin_tool_ids.json) and a measured
kiro-cli version kirocrew doctor warns past. The KAS projection carries
each kiro-cli built-in with its KAS family beside it (read_file,
list_directory, grep_search, file_search, str_replace, fs_append); a mount
family stops at what the kiro-cli tool can do, so delete_file mounts only
when a spec names it, while an excludedTools entry reaches everything
governed under the name.

The PreToolUse gate reads the table the other way: a KAS built-in (no MCP
server) is evaluated under its kiro-cli name in the deny tier, the
tools-scope ceiling, and the read-only auto-approve classifier, so
auto_deny_tools ["fs_write"] binds str_replace and ["execute_bash"] binds
the shell's run_command, and a KAS read auto-approves under --approval
reads where fs_read does. An MCP server's own read_file is not touched:
KAS names the server on the tool_call as _meta.kiro.serverName and the
tool on the permission request as _meta.kiro.mcpTool.identity, both read by
_dispatch; a built-in stamps only _meta.kiro.toolId, read as the tool name
when the cache holds none. A delete is on the write plane (WRITE_PLANE_KINDS),
so delete_file's targetFile reaches the sensitive-path keystone and the
write-protected-config tier in both gate planes.
@billygerhard

Copy link
Copy Markdown
Contributor Author

Re-rolled 23b653231c -> 733b6880d1: identical patch (same patch-id), rebased onto main decba81940. On 23b653231c every test shard was green (all 8 Windows shards included), all six review lanes reported no blocking findings, and the one red was SAST (Semgrep) failing to pull its image (toomanyrequests from Docker Hub, before any scan ran). Re-rolling for that runner condition only.

@billygerhard

Copy link
Copy Markdown
Contributor Author

Superseded by #17280 (merged as 52f909c), which ported this change onto main with the maintainer extensions. Closing.

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