test(setup): add nested-workspace + polyglot-monorepo layouts

Extends the setup-flow matrix with an `SM_LAYOUT` dimension modelling
real-world deployments beyond a single project:

- workspace (npm, pnpm, yarn, pip, uv): a root + several members,
  including a deeply-nested member and one with no dependency on the
  patched package. Exercises `setup`'s workspace handling — npm/yarn
  write the hook to every member, pnpm only to the root — and the
  cross-workspace apply on a single root install. npm/pnpm/yarn apply
  (the dependency hoists / lands in the pnpm store and is patched once);
  pip (nested requirements) and uv (uv workspace, one shared .venv) are
  Python gaps.
- monorepo: a polyglot repo with an npm workspace alongside
  python/rust/go/php/ruby/nuget/deno manifests. Confirms `setup` works in
  a mixed environment — it configures the npm hooks and does not choke on
  the foreign manifests; a root `npm install` then patches the npm slice.
  Runs in the npm image; the foreign manifests are present to test
  setup's robustness, not installed.

Wiring: `matrix.json` gains workspace_targets/scenarios and
monorepo_targets/scenarios; `run-case.sh` gains layout-aware scaffold /
install / multi-target verification; `scripts/setup-matrix.sh` threads a
`layout` column (+ `query --layout`); the Rust harness gains
`run_workspace_pm` / `run_monorepo`, with `*_workspace` tests on the
npm/pypi wrappers and a new `setup_matrix_monorepo.rs`.

Real-world finding (and fix in the harness): the install hook's `apply`
must run with the package manager's per-script cwd — root for the
project, the member dir for each member — so member postinstalls find no
manifest and no-op while the root applies. The driver therefore does NOT
pin SOCKET_CWD; pinning it to the root makes every member apply target
the root manifest and fail mid-install with "no packages found on disk",
breaking `npm install` in a workspace.

Verified in Docker (socket-patch 3.3.0): npm/pnpm/yarn workspace and the
monorepo apply (pass); pip/uv workspace are known_gap; single-project
cases unchanged. 92 cases total; 0 regressions.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: mikolalysenko

crates/socket-patch-cli/tests/setup_matrix_common/mod.rs

@@ -94,6 +94,7 @@ struct Case {
     apply_ecosystems: String,
     marker: String,
     alt_marker: String,
+    layout: String,
 }
 
 impl Case {
@@ -121,29 +122,40 @@ impl Case {
             ("SM_APPLY_ECOSYSTEMS".into(), self.apply_ecosystems.clone()),
             ("SM_MARKER".into(), self.marker.clone()),
             ("SM_ALT_MARKER".into(), self.alt_marker.clone()),
+            ("SM_LAYOUT".into(), self.layout.clone()),
         ]
     }
 }
 
-/// Load every case for a given (ecosystem, pm) by crossing that target
-/// with all scenarios in the spec.
-fn load_cases(ecosystem: &str, pm: &str) -> Vec<Case> {
+/// Load every case for a given (ecosystem, pm) by crossing the matching
+/// target in `targets_key` with every scenario in `scenarios_key`,
+/// tagging each with `layout`. `targets_key`/`scenarios_key` select the
+/// spec section: ("targets","scenarios") for single projects,
+/// ("workspace_targets","workspace_scenarios") for nested workspaces,
+/// ("monorepo_targets","monorepo_scenarios") for the polyglot monorepo.
+fn load_section(
+    targets_key: &str,
+    scenarios_key: &str,
+    layout: &str,
+    ecosystem: &str,
+    pm: &str,
+) -> Vec<Case> {
     let text = std::fs::read_to_string(matrix_path())
         .unwrap_or_else(|e| panic!("read matrix.json: {e}"));
     let spec: serde_json::Value =
         serde_json::from_str(&text).expect("parse matrix.json");
     let marker = spec["marker"].as_str().unwrap_or("").to_string();
     let alt_marker = spec["alt_marker"].as_str().unwrap_or("").to_string();
 
-    let target = spec["targets"]
+    let target = spec[targets_key]
         .as_array()
-        .expect("targets array")
+        .unwrap_or_else(|| panic!("{targets_key} array missing"))
         .iter()
         .find(|t| t["ecosystem"] == ecosystem && t["pm"] == pm)
-        .unwrap_or_else(|| panic!("no target for {ecosystem}/{pm} in matrix.json"));
+        .unwrap_or_else(|| panic!("no {targets_key} entry for {ecosystem}/{pm}"));
 
     let mut cases = Vec::new();
-    for s in spec["scenarios"].as_array().expect("scenarios array") {
+    for s in spec[scenarios_key].as_array().expect("scenarios array") {
         let scenario = s["id"].as_str().unwrap().to_string();
         cases.push(Case {
             id: format!("{ecosystem}/{pm}/{scenario}"),
@@ -162,6 +174,7 @@ fn load_cases(ecosystem: &str, pm: &str) -> Vec<Case> {
             apply_ecosystems: target["apply_ecosystems"].as_str().unwrap().to_string(),
             marker: marker.clone(),
             alt_marker: alt_marker.clone(),
+            layout: layout.to_string(),
         });
     }
     cases
@@ -222,22 +235,44 @@ fn run_case(case: &Case) -> RunResult {
     }
 }
 
-/// Run every scenario for one (ecosystem, pm) and assert each meets the
-/// ASPIRATIONAL expectation. Soft-skips when Docker / the ecosystem
-/// image is unavailable (container mode) — matching the `docker_e2e_*`
-/// convention where Rust integration tests have no native "skipped".
+/// Run the single-project scenarios for one (ecosystem, pm).
 pub fn run_pm(ecosystem: &str, pm: &str) {
+    run_cases(
+        &format!("{ecosystem}/{pm}"),
+        load_section("targets", "scenarios", "single", ecosystem, pm),
+    );
+}
+
+/// Run the nested-workspace scenarios for one (ecosystem, pm).
+pub fn run_workspace_pm(ecosystem: &str, pm: &str) {
+    run_cases(
+        &format!("{ecosystem}/{pm} [workspace]"),
+        load_section("workspace_targets", "workspace_scenarios", "workspace", ecosystem, pm),
+    );
+}
+
+/// Run the polyglot all-ecosystem monorepo scenarios.
+pub fn run_monorepo() {
+    run_cases(
+        "monorepo",
+        load_section("monorepo_targets", "monorepo_scenarios", "monorepo", "monorepo", "mono"),
+    );
+}
+
+/// Execute a set of cases and assert each meets the ASPIRATIONAL
+/// expectation. Soft-skips when Docker / the ecosystem image is
+/// unavailable (container mode) — matching the `docker_e2e_*` convention
+/// where Rust integration tests have no native "skipped".
+fn run_cases(label: &str, cases: Vec<Case>) {
     if !host_mode() && !docker_on_path() {
-        eprintln!("skip {ecosystem}/{pm}: docker not on PATH (set SOCKET_PATCH_TEST_HOST=1 to run on host)");
+        eprintln!("skip {label}: docker not on PATH (set SOCKET_PATCH_TEST_HOST=1 to run on host)");
         return;
     }
-
-    let cases = load_cases(ecosystem, pm);
     if !host_mode() {
         if let Some(c) = cases.first() {
             if !image_present(&c.image) {
                 eprintln!(
-                    "skip {ecosystem}/{pm}: image socket-patch-test-{}:latest not present \
+                    "skip {label}: image socket-patch-test-{}:latest not present \
                      (build it: scripts/setup-matrix.sh build --ecosystem {})",
                     c.image, c.image
                 );
@@ -267,12 +302,11 @@ pub fn run_pm(ecosystem: &str, pm: &str) {
 
     assert!(
         failures.is_empty(),
-        "{}/{}: {} of {} setup-matrix case(s) did not meet the aspirational \
+        "{}: {} of {} setup-matrix case(s) did not meet the aspirational \
          expectation. BASELINE GAP entries are the experimental TODO list \
          (this suite is non-blocking in CI); REGRESSION / LEAK entries are \
          real problems:\n{}",
-        ecosystem,
-        pm,
+        label,
         failures.len(),
         cases.len(),
         failures.join("\n")

crates/socket-patch-cli/tests/setup_matrix_monorepo.rs

@@ -0,0 +1,20 @@
+//! setup-matrix: polyglot all-ecosystem monorepo.
+//!
+//! A single repo containing an npm workspace alongside
+//! python/rust/go/php/ruby/nuget/deno manifests. Confirms `socket-patch
+//! setup` works in this mixed environment — it must configure the npm
+//! hooks and NOT choke on the foreign manifests; a root `npm install`
+//! then applies the patch to the npm slice. Runs in the npm image (the
+//! only one with the npm toolchain); the foreign manifests are present
+//! to test setup's robustness, not installed.
+//!
+//! Run: `cargo test -p socket-patch-cli --features setup-e2e --test setup_matrix_monorepo`
+#![cfg(feature = "setup-e2e")]
+
+#[path = "setup_matrix_common/mod.rs"]
+mod smc;
+
+#[test]
+fn monorepo() {
+    smc::run_monorepo();
+}

crates/socket-patch-cli/tests/setup_matrix_npm.rs

@@ -31,3 +31,25 @@ fn pnpm() {
 fn bun() {
     smc::run_pm("npm", "bun");
 }
+
+// ── Nested-workspace layouts ──────────────────────────────────────────
+// A root + several members (incl. a deeply-nested one and a member with
+// no dependency on the patched package). Exercises `setup`'s workspace
+// handling (npm/yarn write the hook to every member; pnpm only to the
+// root) plus the cross-workspace apply on the root install. These should
+// PASS — they're real regression guards, not gap documentation.
+
+#[test]
+fn npm_workspace() {
+    smc::run_workspace_pm("npm", "npm");
+}
+
+#[test]
+fn pnpm_workspace() {
+    smc::run_workspace_pm("npm", "pnpm");
+}
+
+#[test]
+fn yarn_workspace() {
+    smc::run_workspace_pm("npm", "yarn");
+}

crates/socket-patch-cli/tests/setup_matrix_pypi.rs

@@ -35,3 +35,18 @@ fn pdm() {
 fn hatch() {
     smc::run_pm("pypi", "hatch");
 }
+
+// ── Nested-workspace layouts (EXPECTED BASELINE GAP) ──────────────────
+// uv workspace (root + members, one shared .venv) and a pip
+// nested-requirements monorepo. Python has no post-install hook, so
+// these don't apply today — but the install itself must succeed.
+
+#[test]
+fn pip_workspace() {
+    smc::run_workspace_pm("pypi", "pip");
+}
+
+#[test]
+fn uv_workspace() {
+    smc::run_workspace_pm("pypi", "uv");
+}

scripts/setup-matrix.sh

@@ -47,23 +47,29 @@ usage() { sed -n '2,40p' "$0" | sed 's/^# \{0,1\}//'; }
 need jq
 [ -f "$MATRIX" ] || die "matrix spec not found: $MATRIX"
 
-# Emit one TSV row per case (target x scenario), honoring filters.
+# Emit one TSV row per case, honoring filters. Covers all three layouts:
+# single (targets x scenarios), workspace (workspace_targets x
+# workspace_scenarios) and monorepo (monorepo_targets x monorepo_scenarios).
 # Columns: id eco pm image hook_family baseline_supported package version
 #          purl manifest_key apply_ecosystems scenario patchset run_setup
-#          expect_applied
+#          expect_applied layout
 cases_tsv() { # $1=eco-filter ("" = all)  $2=pm-filter  $3=scenario-filter
   jq -r --arg eco "${1:-}" --arg pm "${2:-}" --arg scn "${3:-}" '
-    .marker as $m | .alt_marker as $am |
-    .targets[] as $t | .scenarios[] as $s |
-    select($eco == "" or $t.ecosystem == $eco) |
-    select($pm  == "" or $t.pm        == $pm)  |
-    select($scn == "" or $s.id        == $scn) |
-    [ ($t.ecosystem + "/" + $t.pm + "/" + $s.id),
-      $t.ecosystem, $t.pm, $t.image, $t.hook_family,
-      ($t.baseline_supported|tostring),
-      $t.package, $t.version, $t.purl, $t.manifest_key, $t.apply_ecosystems,
-      $s.id, $s.patchset, ($s.run_setup|tostring), ($s.expect_applied|tostring)
-    ] | @tsv
+    def rows($targets; $scenarios; $layout):
+      $targets[] as $t | $scenarios[] as $s
+      | select($eco == "" or $t.ecosystem == $eco)
+      | select($pm  == "" or $t.pm        == $pm)
+      | select($scn == "" or $s.id        == $scn)
+      | [ ($t.ecosystem + "/" + $t.pm + "/" + $s.id),
+          $t.ecosystem, $t.pm, $t.image, ($t.hook_family // ""),
+          ($t.baseline_supported|tostring),
+          $t.package, $t.version, $t.purl, $t.manifest_key, $t.apply_ecosystems,
+          $s.id, $s.patchset, ($s.run_setup|tostring), ($s.expect_applied|tostring),
+          $layout ]
+      | @tsv;
+    rows(.targets; .scenarios; "single"),
+    rows((.workspace_targets // []); (.workspace_scenarios // []); "workspace"),
+    rows((.monorepo_targets // []);  (.monorepo_scenarios // []);  "monorepo")
   ' "$MATRIX"
 }
 
@@ -101,9 +107,9 @@ cmd_list() {
             scenario:$s.id, image:$t.image, hook_family:$t.hook_family,
             baseline_supported:$t.baseline_supported, expect_applied:$s.expect_applied } ]' "$MATRIX"
   else
-    printf '%-44s %-9s %-8s %-22s %s\n' ID ECO PM SCENARIO EXPECT
-    cases_tsv "" "" "" | while IFS=$'\t' read -r id eco pm image hook bsup pkg ver purl key aeco scn pset rsetup expect; do
-      printf '%-44s %-9s %-8s %-22s %s\n' "$id" "$eco" "$pm" "$scn" "$expect"
+    printf '%-46s %-9s %-8s %-11s %-22s %s\n' ID ECO PM LAYOUT SCENARIO EXPECT
+    cases_tsv "" "" "" | while IFS=$'\t' read -r id eco pm image hook bsup pkg ver purl key aeco scn pset rsetup expect layout; do
+      printf '%-46s %-9s %-8s %-11s %-22s %s\n' "$id" "$eco" "$pm" "$layout" "$scn" "$expect"
     done
   fi
 }
@@ -142,14 +148,15 @@ cmd_run() {
   fi
 
   local total=0
-  while IFS=$'\t' read -r id eco_ pm_ image hook bsup pkg ver purl key aeco scn_ pset rsetup expect; do
+  while IFS=$'\t' read -r id eco_ pm_ image hook bsup pkg ver purl key aeco scn_ pset rsetup expect layout; do
     [ -z "$id" ] && continue
     total=$((total+1))
-    echo ">> [$total] $id" >&2
+    echo ">> [$total] $id (layout=$layout)" >&2
 
     # Common SM_* env for the driver.
     local -a base_env=(
       "SM_ID=$id" "SM_ECOSYSTEM=$eco_" "SM_PM=$pm_" "SM_SCENARIO=$scn_"
+      "SM_LAYOUT=$layout"
       "SM_PATCHSET=$pset" "SM_RUN_SETUP=$([ "$rsetup" = true ] && echo 1 || echo 0)"
       "SM_EXPECT_APPLIED=$([ "$expect" = true ] && echo 1 || echo 0)"
       "SM_PACKAGE=$pkg" "SM_VERSION=$ver" "SM_PURL=$purl"
@@ -182,23 +189,23 @@ cmd_run() {
     if [ "$expect" = true ] && [ "$bsup" = true ]; then bl=true; fi
 
     if [ -n "$result" ] && printf '%s' "$result" | jq -e . >/dev/null 2>&1; then
-      printf '%s\n' "$result" | jq -c --argjson bl "$bl" --arg img "$image" --arg hk "$hook" '
+      printf '%s\n' "$result" | jq -c --argjson bl "$bl" --arg img "$image" --arg hk "$hook" --arg lay "$layout" '
         . as $r |
         ($r.actual_applied == $r.expect_applied) as $ideal |
         ($r.actual_applied == $bl) as $base |
         (if $ideal and $base then "pass"
          elif $ideal and ($base|not) then "progress"
          elif ($ideal|not) and $base then "known_gap"
          else "regression" end) as $cls |
-        $r + {baseline_applied:$bl, classification:$cls, image:$img, hook_family:$hk, driver_rc:'"$rc"'}
+        $r + {baseline_applied:$bl, classification:$cls, layout:$lay, image:$img, hook_family:$hk, driver_rc:'"$rc"'}
       ' >> "$jsonl"
     else
       # No parseable result — surface as an error case.
       jq -nc --arg id "$id" --arg eco "$eco_" --arg pm "$pm_" --arg scn "$scn_" \
-             --arg pset "$pset" --arg img "$image" --arg hk "$hook" --argjson bl "$bl" '
+             --arg pset "$pset" --arg img "$image" --arg hk "$hook" --arg lay "$layout" --argjson bl "$bl" '
         { id:$id, ecosystem:$eco, pm:$pm, scenario:$scn, patchset:$pset,
           expect_applied:null, actual_applied:null, baseline_applied:$bl,
-          classification:"error", image:$img, hook_family:$hk, driver_rc:'"$rc"',
+          classification:"error", layout:$lay, image:$img, hook_family:$hk, driver_rc:'"$rc"',
           notes:"driver produced no parseable result" }' >> "$jsonl"
     fi
   done < <(cases_tsv "$eco" "$pm" "$scn")
@@ -239,21 +246,23 @@ print_summary() { # $1 = results file
 
 # --------------------------------------------------------------------- query / results
 cmd_query() {
-  local status="" eco="" pm="" scn=""
+  local status="" eco="" pm="" scn="" lay=""
   while [ $# -gt 0 ]; do case "$1" in
     --status) status="$2"; shift 2;;
     --ecosystem) eco="$2"; shift 2;;
     --pm) pm="$2"; shift 2;;
     --scenario) scn="$2"; shift 2;;
+    --layout) lay="$2"; shift 2;;
     *) die "query: unknown arg '$1'";;
   esac; done
   [ -f "$LATEST" ] || die "no results yet — run '$0 run' first"
-  jq --arg st "$status" --arg eco "$eco" --arg pm "$pm" --arg scn "$scn" '
+  jq --arg st "$status" --arg eco "$eco" --arg pm "$pm" --arg scn "$scn" --arg lay "$lay" '
     [ .cases[]
       | select($st  == "" or .classification == $st)
       | select($eco == "" or .ecosystem == $eco)
       | select($pm  == "" or .pm == $pm)
-      | select($scn == "" or .scenario == $scn) ]' "$LATEST"
+      | select($scn == "" or .scenario == $scn)
+      | select($lay == "" or .layout == $lay) ]' "$LATEST"
 }
 
 cmd_results() {