Skip to content

fix(pi): run pi under a Node that meets its engine floor - #22883

Merged
bolichen97 merged 2 commits into
mainfrom
fix/pi-node-engine-guard
Oct 21, 2026
Merged

bolichen97 merged 2 commits into
mainfrom
fix/pi-node-engine-guard

Conversation

@kyleseaman

@kyleseaman kyleseaman commented Oct 21, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: a pi session on a host whose PATH puts an old Node.js first either starts under a Node that pi supports, or is refused with a message that names the Node, its version and the version pi needs.

pi's bin is #!/usr/bin/env node and pi declares "engines": {"node": ">=22.19.0"}. The PATH the pi child inherits is augmented_path(...), which puts directories like /usr/local/bin and /opt/homebrew/bin ahead of the inherited PATH. When an older system Node lives there, every pi session runs pi under it: pi dies at module load and the gate read-back refuses with only exit 1: its configuration could not be parsed. Found by #22807's real-adapter lane (its "Observation" and line-33 notes); reproduced on a dev desktop whose global mise default is Node 16.

Why it matters

Anyone with an older Node first on that PATH (a system Node in /usr/local/bin, a Homebrew Node, a version manager's global default) cannot use pi at all, and the error points at a config file rather than at Node, so nothing tells them what to fix.

Not a goal

What changed (motivation → approach → change)

Symptom: pi under too old a Node → read-back exit 1: its configuration could not be parsed. Root cause: the shebang's env takes the first node on the child's PATH, and nothing compared that Node with pi's declared engine. Fix, before the seal, the launcher and the read-back:

  • src/kiro_crew/acp/harness/pi_node.py (new): choose_pi_node reads the shebang of pi's resolved script (#!/usr/bin/env node → the first executable node on the child's PATH, the same lookup env does; an absolute #!/…/node → that file), runs node --version and compares it with the floor.
    • At or above the floor: no change, the launcher execs pi exactly as before.
    • Below it: looks for a Node that meets the floor beside the pi link, in pi's npm prefix (<prefix>/bin/node), then later on the same PATH, and returns (node, pi's script) for the launcher.
    • None qualifies: refuses with e.g. pi needs Node.js 22.19.0 or newer (the 'engines' floor in its package.json), but the Node.js it would run under is /usr/local/bin/node, v18.20.4, and no Node.js that new was found beside pi or later on that PATH. Install Node.js 22.19.0 or newer and put it ahead of /usr/local/bin on PATH, then start a new chat.
    • Left alone (the read-back still decides): Windows, a pi that is not a plain Node script, a shebang with interpreter arguments, a Node whose version cannot be read, and a pi whose manifest declares no readable engines.node. No floor is guessed: every pi release from PI_MIN_VERSION (0.99.2) through 1.3.0 declares >=22.19.0 (npm view @earendil-works/pi-coding-agent@<v> engines.node for 0.99.2, 1.0.0, 1.1.0, 1.2.0, 1.3.0), so the guard reads it rather than hard-coding it.
    • node_engine_floor reads the lower bound of engines.node (>=, ^, ~, bare/x versions, || alternatives → their minimum, upper bounds ignored); anything else is unreadable. Version parsing and formatting reuse kiro_crew.constants.parse_node_version / format_node_version.
    • The probe: environment of only PATH and HOME, stdin closed, 10s timeout, cwd = the session's directory (so a version-manager shim answers as it will for pi), and run through a caller-supplied wrap for the life of the child.
  • src/kiro_crew/acp/harness/pi.py:
    • _pi_manifest factored out of _pi_installed_version so the version and the engine floor read the same manifest; _pi_node_floor returns the declared floor or None.
    • _pi_probe_wrap confines each node --version child with wrap_argv in the session's sandbox mode with the same extra_hidden_dirs / extra_expose_files as the gate read-back, and reclaims the launcher file when the child exits. The Node comes off the session's PATH (some of whose directories the agent can write) and a shim reads config from the agent's work dir, so the probe gets the read-back's confinement, as the opencode version probe does.
    • resolve_spawn runs _pi_node_choice right after the sandbox floor check (the probe is a child) and before the seal; an issue raises AcpError before the launcher or read-back child.
    • _pi_gate_launcher_body / _ensure_pi_gate_launcher take an optional program: exec <node> <pi script> "$@" --extension <sealed gate>. The launcher cache is keyed on it. The read-back runs this same launcher, so the gate is still verified on exactly the process the session gets.
  • test/spawn_audit_helpers.py: acp/harness/pi_node.py::_node_version listed beside _opencode_reported_major, with the same justification shape (fixed --version argv, wrapped by the caller, nothing from a turn).
  • docs/system-specs/modules/agent-host-contract.md: pi's failure-mode cell names the guard.

Read-back stderr: the refusal already carries pi's stderr as a diagnosis drawn from the closed vocabulary in acp/launch.py (_READBACK_FAULT_SHAPES), and on purpose never echoes the child's bytes (the comment there gives the measured credential-leak reason). This PR keeps that. It makes the Node cause visible by refusing earlier with a message built from facts Crew read itself (path, version, floor), not by printing child output.

Known limit: in the chosen-Node path only pi's own interpreter changes; the child's PATH still lists the old node first for anything pi's tools spawn. #22542's PATH-order fix is the general answer to that.

Strings: the new refusal follows the convention of every other AcpError in acp/harness/pi.py, which are English backend messages outside the i18n catalogs; no frontend string changed, so i18n:check is not affected.

Sensitive Change Review: no watched file touched (checked the diff against SENSITIVE_GLOBS with fnmatch). Stays out of #22808's files.

Backwards compatibility

Compatible: on a host where the shebang already finds a Node at or above the floor, or where pi declares no floor, the launcher body is byte-identical to main; the only added work is the sandboxed node --version probe. The new outcomes are for sessions that used to fail at the read-back: they now start under a qualifying Node, or fail earlier with a clearer message.
The one take-away shape is the credential mask (extra_hidden_dirs=) on the new node --version probe child. Nothing that runs on main gains a mask: the mask is the gate read-back's, applied only to the new probe. Readers of what it hides, i.e. the probe itself on every entry that starts a pi session:
Reader: src/kiro_crew/acp/harness/pi_node.py:_node_version -- chat -- a Node pi can already run under, inside this same mask on main (the read-back and the session), can still print its version under it; test_the_node_probe_runs_after_the_sandbox_floor_under_its_mask
Reader: src/kiro_crew/acp/harness/pi.py:PiLaunch.resolve_spawn -- subagent -- a pi subagent spawns through the same resolve_spawn and sandbox mode, so its probe gets the same mask as its own read-back; test_the_spawn_hands_the_chosen_node_to_the_launcher
Reader: src/kiro_crew/acp/harness/pi.py:PiLaunch.resolve_spawn -- cron -- a cron turn on pi spawns the same way; an unreadable version under the mask leaves the launch unchanged (test_a_node_whose_version_cannot_be_read_is_left_to_the_read_back)
Otherwise no key, path, function or check is removed; _pi_installed_version keeps its signature and results (its manifest walk moved into _pi_manifest; existing tests unchanged and passing).

Tests

test/test_acp_pi_node_guard.py (new; real files: a fake npm prefix holding pi's manifest/script/link and fake node executables):

  • engine range parsing (12 cases incl. ||, upper bounds, hyphen ranges, junk → unreadable);
  • old Node with only too-old candidates → refuse naming path, v18.20.4, 22.19.0, the engines source; no Node on PATH → refuse;
  • Node at the floor → unchanged launch;
  • explicit choice: Node beside pi beats an older one first on PATH; newer later on PATH; Node in pi's npm prefix when pi is linked from elsewhere;
  • absolute #!/…/node shebang is checked; non-Node / interpreter-arg shebangs and an unreadable version are left to the read-back;
  • floor read from the manifest; absent / {} / >22 / non-dict engines → no floor, and _pi_node_choice then probes nothing and changes nothing even under Node 18;
  • the version probe sees no gateway environment (NODE_OPTIONS, other vars), and every version child goes through the wrap;
  • resolve_spawn: the probe runs after the sandbox floor check and before the seal, through wrap_argv with the read-back's mode/hidden/expose, its launcher reclaimed only after the child; an issue refuses before seal/launcher/wrap/read-back; the chosen program reaches the launcher; all off the loop;
  • launcher body and cache with a program.

Mutation check (each applied, the file re-run, reverted): 17/17 killed: current-meets-floor, refuse-when-none, candidate-must-meet-floor, beside-pi candidates, later-on-PATH candidates, absolute shebang, minimal probe env, floor-from-manifest, no-floor-leaves-pi-alone, spawn refuses, launcher gets program, body uses program, cache keyed on program, range upper-bound check, probe goes through wrap, spawn passes the sandbox wrap, wrap reclaims its launcher.

Updated: test/acp_pi_backend_helpers.py (the launch rig stubs the node choice and records a program), test/acp_launch_capture.py (goldens pin the node choice so they do not depend on the host's Node).

Also run: test_acp_pi_backend*.py, test_acp_pi_crew_tools.py, test_acp_refactor_facade.py, test_acp_launch_goldens.py, test_spawn_audit.py (717 passed); HARNESS_BASE_REF=origin/main check_harness_parity.py, brand, comment-history, file-line-cap, feature-map, cwd-relative reads, subprocess-encoding, sync-io-in-async, agent-sdk-boundary, docs-lint (pass); black, isort, flake8, mypy on the changed files (clean).

Manual verification

On a dev desktop with pi 1.3.0 installed under mise Node 24.18.0 and Node 16.20.2 first on the PATH:

  • launcher without a program (main's behaviour) + get_commands → exit 1, diagnosis its configuration could not be parsed (the reported symptom);
  • choose_pi_node with the real _pi_probe_wrap picks …/node/24.18.0/bin/node beside pi; the launcher with that program answers get_commands with the gate's commands, exit 0.

Related Issues

Complements #22542 (general PATH order). Found by #22807.

Pattern harvest

Not generalizable: the defect is specific to a harness shipped as an env node script with a declared engine floor; the only such harness is pi, and the guard now lives in its launch.

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title
  • Existing tests pass and new tests added for new functionality
  • Self-review completed; code follows project style guidelines
  • Documentation updated (if applicable)
  • No secrets, credentials, or internal references in the diff

Contribution License Agreement

Contributions are accepted under the project's Apache-2.0 license.

…e naming it

pi's bin is '#!/usr/bin/env node' and pi declares engines.node >=22.19.0.
When the PATH the pi child inherits puts an older node first, pi died at
module load and the gate read-back refused with only 'exit 1: its
configuration could not be parsed'.

Before the read-back, resolve the node pi's shebang would find on the
child's PATH and compare its version to the floor read from pi's own
package.json (fallback constant only when none is declared). Below the
floor, run pi under a node that meets it (beside the pi link, in pi's npm
prefix, or later on the PATH) through the gate launcher; refuse with the
node path, its version and the floor when none qualifies.
@kyleseaman
kyleseaman requested review from a team and KiroCrewCaptain as code owners October 21, 2026 19:48
@kyleseaman
kyleseaman requested a review from bolichen97 October 21, 2026 19:48
@github-actions github-actions Bot added the readiness: checking Automated validation is still running label Oct 21, 2026

@bolichen97 bolichen97 left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

Reviewed at 4c09690.

The guard is well scoped. It reads the shebang and the engine floor from files Crew already trusts, and it refuses with facts Crew read itself, not with child output. It leaves the launcher byte-identical when the first Node meets the floor. The gate read-back still runs on the exact launcher the session gets, so a chosen Node that the sandbox cannot reach still fails closed. The tests drive real files and fake node executables, and the cache key change covers the new launcher variant.

One hardening request, inline: the new node --version probe runs outside the sandbox in the session directory, so it should not execute a node found through a relative PATH entry.

Checked: the probe PATH matches the read-back PATH (the spawn env resolver does not change PATH), the Windows path is untouched, and no file is on the security path denylist. Not yet possible: readiness is still checking and the AI review lanes are pending on this head, so this is a comment, not an approval. I will re-check after readiness settles.

"""Every executable ``node`` on *search_path*, in the order ``env`` tries them."""
found: list[str] = []
for entry in search_path.split(os.pathsep):
candidate = os.path.join(entry, _NODE) if entry else ""

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.

The version probe can run a work-dir-relative node outside the sandbox.

_nodes_on_path joins every PATH entry as given, and _node_version runs each candidate with cwd set to the session directory and no sandbox wrap. augmented_path validates the directories it adds as absolute, but it passes the inherited PATH through unchanged. So a relative entry such as . or bin resolves against the session directory, and the probe executes a node file from the project tree with the gateway's own privileges. pi itself would also hit that entry through env, but inside the sandbox; the probe also runs "later on PATH" candidates that pi would never run.

for entry in search_path.split(os.pathsep):
    candidate = os.path.join(entry, _NODE) if entry else ""

Suggestion: skip non-absolute entries here (if entry and os.path.isabs(entry)), the same rule augmented_path applies to its own directories. pi still runs under its shebang lookup for that case, and the read-back decides as before. If the inherited PATH is already filtered to absolute entries somewhere upstream of this call, point me at it and I will withdraw this.

Rule: a probe that runs before the sandbox must not execute anything the session directory can supply.

@github-actions

github-actions Bot commented Oct 21, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Opus 5.5) — ✅ PASS

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

UX-Verdict: PASS

Nothing to check. The change is backend-only: no file under website/ and no user-visible control was added or changed, so the missing screenshots and blind read leave no evidence gap.

Notes

  • The new refusal in pi_node.py (_too_old_issue) is one three-clause sentence followed by the fix. Put the fix first and keep the path as the rest of the message, for example: "Install Node.js 22.19.0 or newer ahead of /usr/local/bin on PATH, then start a new chat. pi found /usr/local/bin/node, v18.20.4."

[UX-REVIEWED] 2201193

Description read

[DESCRIPTION-READ] 802c60f9ec4122ba10ac924e5e83d91a8974620c9ae6fdaeb1508d2c723a7630

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

@github-actions

github-actions Bot commented Oct 21, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Opus 5.5) — ✅ PASS

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

Design-Verdict: PASS

Nothing blocks. The guard reads the floor from pi's own manifest instead of guessing one. It leaves pi alone whenever it can't read a fact, and the read-back still checks the exact launcher the session runs.

Notes

  • Every pi spawn now runs at least one sandboxed node --version child, and more when it has to search for a newer Node. Nothing is cached, not even when the PATH and the resolved node are unchanged. A cache keyed on the Node's path and modification time would remove that repeated startup cost.
  • In the chosen-Node path, anything pi's tools spawn still finds the old node first. The description scopes that out to fix(env): stop augmented_path re-prepending dirs the inherited PATH already has #22542, which is reasonable, but a log line naming the too-old Node it skipped would make the remaining gap easier to diagnose.

[DESIGN-REVIEWED] 2201193

Description read

[DESCRIPTION-READ] 3a2da8b20a30cdd4480a4df6c6aa6db02816e10bdcc379225099fb9c834b08a2

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

@github-actions

github-actions Bot commented Oct 21, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Opus 5.5) — ✅ PASS

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

First-Principles-Verdict: PASS

Nothing blocks: each item serves the frozen Goal, is fail-safe when anything is unreadable, and the PATH-order root cause is explicitly deferred to #22542.

What this change ships

Inventory (7 items) — 7 justified

Intent: let someone whose PATH puts an old Node first either run pi under a supported Node or get a refusal naming the Node, its version and the floor — FIX.

  1. A pi session whose shebang finds a Node below pi's engines.node floor now launches pi under a qualifying Node found beside pi, in its npm prefix or later on PATH — justified
  2. When no qualifying Node exists, the session is refused before launch with the path, the version and the floor, instead of configuration could not be parsed — justified
  3. A new sandboxed node --version child runs on every pi spawn (PATH+HOME env, 10s timeout, session sandbox mask) — justified
  4. The floor is read from pi's own manifest; no manifest, no declared floor or an unreadable range leaves behaviour unchanged — justified
  5. Windows, non-Node shebangs, shebangs with interpreter arguments and an unreadable Node version are left to the existing read-back — justified
  6. The gate launcher can exec node <pi script> in place of pi, and its cache key includes that program — justified
  7. pi's row in the agent-host-contract failure-mode table names the guard — justified

[FIRST-PRINCIPLES-REVIEWED] 2201193

Description read

[DESCRIPTION-READ] 9d89f794382dc2b9bd95848b70d3e477ba28f74f15471801d2be68be59854784

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

@github-actions

github-actions Bot commented Oct 21, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5.5 Review — ✅ no blocking findings

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

Review details

No findings.

[OPUS-REVIEWED] 2201193

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

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

@github-actions

github-actions Bot commented Oct 21, 2026 •

Copy link
Copy Markdown
Contributor

GPT 6.1 Review — ✅ no blocking findings (all downgraded on adjudication)

GPT 6.1 flagged blocking issues on 2201193229cec4612631746c3fd68cf2808191d6; Opus 5.5 adjudication downgraded every one of them. Downgraded: the remedy each one needs is disproportionate to the harm it prevents. Adjudication downgraded all 1 blocking finding(s): the remedy each one requires is disproportionate to the harm it prevents.

This comment is updated in place on each push.

Review details

BLOCKING -- src/kiro_crew/change_card_catalog.py:1816 -- Fence the interval shown when enabling heartbeat

every = p.get("interval", before_ci.get("interval"))
Trigger: Apply a card requesting heartbeat=True, interval=240 while the stored interval is already 240; another owner schedules request saves interval=30 during the middleware’s awaited checkpoint, after its snapshot check but before api_member_goals_schedules.
Outcome: The unchanged interval is omitted from both the apply body and expected, so the locked write enables a 30-minute heartbeat—up to 48 paid turns/day—despite the card displaying up to 6.
Anchor: defect
Fix: Include the snapshot interval in the apply plan’s expected whenever heartbeat is enabled, even when the interval is unchanged, so the existing locked comparison refuses this race.

[BLOCK-MERGE-DOWNGRADED] 2201193
[GPT-REVIEWED] 2201193

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

F1 is downgraded, so nothing in this run keeps the merge blocked.

F1: harm is LOW to MEDIUM.

  • Conditions: The apply step's expected lists only the fields that changed (src/kiro_crew/change_card_catalog.py:1826), while the shown interval is read from the snapshot (:1816). The handler checks expected only inside _schedule_lock, at set_schedules (src/kiro_crew/dashboard/handlers/member_goals.py:482-485). So the failure needs a second owner to save a different interval, with a schedules request of their own, inside the gap between snapshot and apply.

  • Consequence: The heartbeat runs more often than the card showed, at an interval an owner deliberately set. That is a visible and recoverable cost in paid turns, not a credential or governance-ceiling issue. There is no automatic recovery (none); the user fixes it by changing or turning off the switch.

  • Why downgrade: This PR changes only acp/harness/pi*.py and its tests. The flagged code is already on main from feat: add an opt-in crewmate heartbeat check-in #21172 (80261cb6), and the PR never touches it. The one-key fix is cheap on its own, but requiring it here means adding work to an unrelated PR, which breaks the one-logical-change rule and the frozen PR goal. That cost outweighs a rare, recoverable spend race that belongs in its own follow-up.

    [ADJUDICATION] 2201193 total=1 uphold=0 downgrade=1
    DOWNGRADE F1 src/kiro_crew/change_card_catalog.py:1816 reason=disproportionate-remedy
    [GPT-ADJUDICATED] 2201193

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

@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 Oct 21, 2026
Each node --version probe now runs under the session's sandbox and
credential mask (wrap_argv with the read-back's hidden/expose set), after
the floor check, because the Node comes off the session's PATH and a
version-manager shim reads config from the agent's work dir. The probe is
listed in the spawn audit beside the opencode version probe it mirrors.

Without a readable engines.node in pi's manifest no floor is assumed and
the read-back decides, as it does for an unreadable Node version. Version
parsing reuses kiro_crew.constants.
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Oct 21, 2026

@bolichen97 bolichen97 left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

Re-reviewed at 2201193, incremental from 4c09690.

My earlier note on the version probe is resolved, by a different route than I suggested. _nodes_on_path still accepts relative PATH entries, but every node --version child now runs through _pi_probe_wrap, which is wrap_argv with the same mode, hidden dirs and exposed files the gate read-back gets. So a node that a relative entry finds in the session directory runs confined exactly as pi would run it, not with the gateway's own privileges. The probe also now runs after the sandbox preflight, the wrap's launcher file is removed once the child exits, and _node_version is listed in the spawn audit next to the opencode version probe. I withdraw the hardening request.

The other change looks right too: with no readable engines.node in pi's manifest, no floor is guessed and the read-back decides, which matches how an unreadable Node version is already handled. Version parsing now reuses the shared helpers in kiro_crew.constants.

Not approving yet:

  • PR Hygiene is red on this head. It asks for a reader list under ## Backwards compatibility, one line per reader in the form Reader: <path>:<symbol> -- <entry> -- <why>, because the diff removes something.
  • Readiness is still checking, and backend, frontend and E2E tests are still running.

I will re-check once those settle.

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running and removed readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention labels Oct 21, 2026
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: passed Eligible automated validation passed for the current revision and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Oct 21, 2026

@bolichen97 bolichen97 left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

Approving at 2201193.

Gates checked on this head: readiness label is passed, the required PR Readiness check is green, PR Hygiene is green on its latest run, every reviewer lane (Opus, GPT, Design, First Principles, UX, Sensitive Change, Security Scope) is green with no block, no required check is red, no other reviewer has requested changes, and there is no linked issue.

[Security: the change adds a child process (the node version probe). It runs through the same sandbox wrap as the gate read-back, with only PATH and HOME in its environment, stdin closed and a 10s timeout, and its fixed argv takes nothing from a turn. No auth, secret, approval gate or trust boundary is touched.]

The earlier note on the probe running unconfined is resolved by the probe wrap. Merging with squash once the queue allows.

@bolichen97
bolichen97 enabled auto-merge (squash) October 21, 2026 22:07
@bolichen97
bolichen97 merged commit 4533b1e into main Oct 21, 2026
121 of 134 checks passed
@bolichen97
bolichen97 deleted the fix/pi-node-engine-guard branch October 21, 2026 22:08
@github-actions github-actions Bot removed the readiness: passed Eligible automated validation passed for the current revision label Oct 21, 2026
buluoray pushed a commit that referenced this pull request Oct 22, 2026
…2951)

* test(pi): stand in for the Node probe's sync sandbox wrap in the real-adapter lane

#22883's node-engine guard confines each 'node --version' probe through _pi_probe_wrap, which calls the sync pi_mod.wrap_argv. The lane (#22807) replaced only wrap_argv_async and the preflight, so on a runner without user namespaces every pi_session test errored at setup with SandboxUnavailableError. Replace the sync wrap by identity too, and say so in the module docstring.

* fix(acp): decide pi's zero-tool record from its declared MCP projection

#22808 gated _mirrorless_member_mounts on two new 'backend in ACP_BACKENDS_SESSION_MCP_ARRAY' tests, which #22489's set-gate ratchet (shrink-only, allowlist 2 for this file) counts, so main reds test_no_new_runtime_site_gates_a_field_backed_line_on_a_set. The question those sites ask is who reads this backend's spec, which registry.PROJECTIONS declares per backend: BROKER_ONLY (pi) means no projection is written and the harness reads no spec of Crew's. Read that record, as this file already does for per_tool_deny, so the file is back to its 2 allowed sites and the zero-tool ban is unchanged.

---------

Co-authored-by: Kyle Seaman <kseam@dev-dsk-kseam-1b-55230d27.us-east-1.amazon.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants