@@ -97,14 +97,16 @@ database does not have.
   repins.** A `link` / `unlink` round trip added a final newline to a `pom.xml` that had none,
   so `git status` showed it modified, and both commands said "repinned ... in `app/pom.xml`"
   for a module pinned only through its parent's `${metaobjects.version}`. The rewrites keep a
-  file's final-newline state, and a repin is reported only for a file whose text changed.
+  file's final-newline state (`pom.xml`, and the blocks appended to `pyproject.toml` and
+  `.npmrc`), and a repin is reported only for a file whose text changed.
   Found by an adopter on 1.1.0-rc.4.
 - **`prerelease-link unlink` removes the git exclude lines `link` added.** `link` appended its
   ignore rules as bare lines to the clone's shared `info/exclude`, and `unlink` left them there.
   They now sit in one managed block, which `unlink` removes without touching a line the user
   wrote, and a repeated `link` does not add them twice. The file is shared by every worktree
-  of the clone, so an entry another linked worktree still needs stays until that worktree is
-  unlinked.
+  of the clone, so an entry that another linked worktree, or another project linked in the same
+  worktree, still needs stays until that one is unlinked. A `NuGet.config` that `link` wrote is
+  removed on `unlink` rather than left as a bare XML declaration.
 - `verify --codegen` (Python, C#) says when the committed output was generated with another
   column rule, another table rule, or both, and names the `naming` setting that reproduces it,
   instead of advising a regeneration that would commit the wrong column or table names.
 
@@ -172,8 +172,8 @@ worktree this is the *shared* exclude file in the clone's common dir (git has no
 per-worktree exclude), so the paths `link` adds there live inside their own managed block
 too: `unlink` removes exactly that block, never a line a user added to the file by hand,
 and a repeated `link` does not duplicate it. An entry that another worktree of the same
-clone still needs, because its own managed file is still linked, stays until that worktree
-is unlinked too. Files that *are* tracked by definition
+clone, or another project linked in the same worktree, still needs stays until that one is
+unlinked too. Files that *are* tracked by definition
 (`pyproject.toml`, `pom.xml`) get a loud warning instead — there is no way to make an edit
 to a tracked file uncommittable, which is precisely why the detector in §5 exists.
 
 
@@ -591,7 +591,7 @@ describe("extractReportSpec: refusals that name what is wrong", () => {
       value: () => root.objects().map((c) => (c.resolutionKey() === fromKey ? fromStub : c)),
     });
     expect(() => extractReportSpec(titles, rootStub, CTX)).toThrow(
-      /report 'ProgramTitles': dimension 'programTitle' @via 'Purchase.program.nowhere' cannot be joined at hop 'nowhere' on 'acme::shop::Program': it names no relationship or identity.reference/,
+      "report 'ProgramTitles': dimension 'programTitle' @via 'Purchase.program.nowhere' does not resolve.",
     );
   });
 
 
@@ -158,34 +158,15 @@ function reportingViaTerminal(
   from: MetaObject,
   root: MetaRoot,
 ): MetaObject | undefined {
-  const walk = walkReportingVia(via, declaring, from, root);
-  return walk !== undefined && "terminal" in walk ? walk.terminal : undefined;
-}
-
-/**
- * {@link reportingViaTerminal}, saying where a walk stopped: `undefined` when the owner does
- * not resolve, else the terminal entity or the hop that failed, the entity it was looked up
- * on and why.
- */
-function walkReportingVia(
-  via: string,
-  declaring: MetaData,
-  from: MetaObject,
-  root: MetaRoot,
-): { terminal: MetaObject } | { hop: string; at: MetaObject; reason: string } | undefined {
   const hops = reportingViaHops(via, declaring, from, root);
   if (hops === undefined) return undefined;
   let current: MetaObject = from;
   for (const hop of hops) {
-    const step = resolveViaHop(current, hop, root);
-    if (step === undefined) return { hop, at: current, reason: "it names no relationship or identity.reference of that entity" };
-    if (step.target === undefined) {
-      const ref = step.hop.attr(step.isReference ? IDENTITY_REFERENCE_ATTR_REFERENCES : RELATIONSHIP_ATTR_OBJECT_REF);
-      return { hop, at: current, reason: `its target '${String(ref ?? "")}' does not resolve to an object` };
-    }
-    current = step.target;
+    const target = resolveViaHop(current, hop, root)?.target;
+    if (target === undefined) return undefined;
+    current = target;
   }
-  return { terminal: current };
+  return current;
 }
 
 /**
@@ -402,15 +383,8 @@ function dimensionField(
   if (dim === undefined) throw unresolved(reportName, `dimension '${item.name}' on '${from.name}'`);
   const via = dim.via();
   // A @via that does not walk is the @via's error, not the @of's (the @of resolves at its end).
-  if (via !== undefined) {
-    const walk = walkReportingVia(via, reportingMemberOwner(dim, from), from, root);
-    if (walk === undefined) throw unresolved(reportName, `dimension '${dim.name}' @via '${via}'`);
-    if (!("terminal" in walk)) {
-      throw new Error(
-        `report '${reportName}': dimension '${dim.name}' @via '${via}' cannot be joined at hop '${walk.hop}' ` +
-          `on '${walk.at.resolutionKey()}': ${walk.reason}.`,
-      );
-    }
+  if (via !== undefined && reportingViaTerminal(via, reportingMemberOwner(dim, from), from, root) === undefined) {
+    throw unresolved(reportName, `dimension '${dim.name}' @via '${via}'`);
   }
   const ref = resolveDimensionOf(dim, from, root);
   if (ref === undefined) throw unresolved(reportName, `dimension '${item.name}' @of`);
 
@@ -197,6 +197,14 @@ finish_rewrite() {  # finish_rewrite <file> <tmpfile> <had 0|1>
   return 0
 }
 
+# The END marker of a block appended to a file, ending in a newline only when the file did
+# before the block was added (<had>, from `had_newline`). The newline that separates the
+# file's last line from the block is the one the block's END would otherwise carry, so
+# `strip_block` hands the file back with its own final-newline state.
+end_block() {  # end_block <had 0|1>
+  if [ "$1" = 1 ]; then echo "$END"; else printf '%s' "$END"; fi
+}
+
 # Remove a managed block from a file, leaving the rest byte-identical.
 strip_block() {  # strip_block <file> <begin> <end>
   local f="$1" b="$2" e="$3" had
@@ -260,12 +268,10 @@ set_exclude_block() {  # set_exclude_block <exclude-file> <lines>
   } > "$ex.tmp" && mv "$ex.tmp" "$ex"
 }
 
-# The OTHER work trees of this clone, one path per line. They read the same exclude file, so
-# an entry one of them still needs must outlive this work tree's `unlink`.
-other_worktrees() {
-  local self
-  self="$(git -C "$PROJECT" rev-parse --show-toplevel 2>/dev/null)" || return 0
-  git -C "$PROJECT" worktree list --porcelain 2>/dev/null | sed -n 's/^worktree //p' | grep -vxF -- "$self" || true
+# Every work tree of this clone, this one included, one path per line. They all read the same
+# exclude file, so an entry any of them still needs must outlive an `unlink`.
+worktrees() {
+  git -C "$PROJECT" worktree list --porcelain 2>/dev/null | sed -n 's/^worktree //p' || true
 }
 
 # Whether a file is one `link` wrote and has not removed: it carries a managed marker, or, for
@@ -656,18 +662,19 @@ link_npm() {
   # pre-release pin and no registry to resolve it from — `link` reported success and the
   # breakage surfaced later as `notarget` inside that sub-project. `check` already walked
   # nested roots; that asymmetry was the bug.
-  local wrote=0 root rel f written=()
+  local wrote=0 root rel f had written=()
   while IFS= read -r root; do
     f="$root/.npmrc"
     strip_block "$f" "$BEGIN" "$END"
     # A pre-existing .npmrc without its own trailing newline would otherwise run its last
     # line straight into the BEGIN marker text (`cat` and `echo "$BEGIN"` land on the same
     # line) — not just a cosmetic newline difference but real content corruption.
-    { if [ -f "$f" ]; then cat "$f"; ends_in_newline "$f" || echo; fi
+    had="$(had_newline "$f")"
+    { if [ -f "$f" ]; then cat "$f"; [ "$had" = 1 ] || echo; fi
       echo "$BEGIN"
       echo "$NPM_SCOPE:registry=$BASE/api/packages/$OWNER/npm/"
       [ -n "$auth" ] && echo "$auth"
-      echo "$END"; } > "$f.tmp" && mv "$f.tmp" "$f"
+      end_block "$had"; } > "$f.tmp" && mv "$f.tmp" "$f"
     rel="${f#"$PROJECT"/}"; [ "$rel" = "$f" ] && rel=".npmrc"
     if tracked "$rel"; then
       warn "$rel is TRACKED in this project — the managed block is committable. Remove it with 'unlink' before pushing."
@@ -697,22 +704,23 @@ link_npm() {
 }
 
 link_py() {
-  local root f n=0
+  local root f had n=0
   while IFS= read -r root; do
     f="$root/pyproject.toml"; n=$((n + 1))
     strip_block "$f" "$BEGIN" "$END"
+    had="$(had_newline "$f")"
     # `explicit = true` + [tool.uv.sources] is per-package index pinning: nothing resolves
     # from this index unless a source names it, so the rest of PyPI is untouched. pip's
     # --extra-index-url has no equivalent, which is why uv is the documented path.
-    { cat "$f"; echo; echo "$BEGIN"
+    { cat "$f"; [ "$had" = 1 ] || echo; echo "$BEGIN"
       echo '[[tool.uv.index]]'
       echo 'name = "metaobjects-prerelease"'
       echo "url = \"$BASE/api/packages/$OWNER/pypi/simple\""
       echo 'explicit = true'
       echo
       echo '[tool.uv.sources]'
       echo "$PY_DIST = { index = \"metaobjects-prerelease\" }"
-      echo "$END"; } > "$f.tmp" && mv "$f.tmp" "$f"
+      end_block "$had"; } > "$f.tmp" && mv "$f.tmp" "$f"
     say "linked ${f#"$PROJECT"/}"
   done < <(py_roots)
   if [ "$n" -eq 0 ]; then warn "no pyproject.toml — configure pip manually, or add one"; return 0; fi
@@ -851,27 +859,18 @@ run_detector() {
 
 # ── unlink ────────────────────────────────────────────────────────────────────────────
 unlink_all() {
-  # The git-exclude block link() wrote — removed by identity, same as every other
-  # managed block, so a line a user added to info/exclude by hand survives untouched. The
-  # file is shared by every work tree of the clone, so an entry another work tree's managed
-  # file still needs stays: dropping it would let `git add -A` there stage an .npmrc that can
-  # hold a registry credential.
-  local ex line wt keep=""
-  ex="$(exclude_file)"
-  if [ -n "$ex" ]; then
-    while IFS= read -r line; do
-      while IFS= read -r wt; do
-        if is_managed_file "$wt/$line"; then keep+="$line"$'\n'; break; fi
-      done < <(other_worktrees)
-    done < <(exclude_block_lines "$ex")
-    set_exclude_block "$ex" "${keep%$'\n'}"
-  fi
   # Every root `link` could have written to, or a sub-project keeps a managed block
   # pointing at a registry that will not serve it once the pre-release is gone.
   local root
   while IFS= read -r root; do strip_block "$root/.npmrc" "$BEGIN" "$END"; done < <(npm_install_roots)
   while IFS= read -r root; do strip_block "$root/pyproject.toml" "$BEGIN" "$END"; done < <(py_roots)
   strip_block "$PROJECT/NuGet.config"  "$XBEGIN" "$XEND"
+  # A NuGet.config `link` wrote is the XML declaration and the managed block, nothing else;
+  # what the strip leaves of it is not a valid config, so it goes. A user's own file, with a
+  # block added by hand, keeps everything outside the block.
+  if [ -f "$PROJECT/NuGet.config" ] && ! grep -v '^<?xml [^>]*?>$' "$PROJECT/NuGet.config" | grep -q '[^[:space:]]'; then
+    rm -f "$PROJECT/NuGet.config"
+  fi
   while IFS= read -r root; do
     strip_block "$root/pom.xml" "$XBEGIN" "$XEND"
     # The http-blocker workaround is a whole file we authored, not a block inside someone
@@ -887,6 +886,22 @@ unlink_all() {
       say "removed the .mvn http-blocker workaround in ${root#"$PROJECT"}"
     fi
   done < <(mvn_roots)
+  # The git-exclude block link() wrote — removed by identity, same as every other
+  # managed block, so a line a user added to info/exclude by hand survives untouched. The
+  # file is shared by every work tree of the clone and names paths from the repository root,
+  # so an entry a managed file still needs stays: one another work tree holds, or another
+  # project linked in this one. Dropping it would let `git add -A` stage an .npmrc that can
+  # hold a registry credential. This runs last, once this project's own files are gone.
+  local ex line wt keep=""
+  ex="$(exclude_file)"
+  if [ -n "$ex" ]; then
+    while IFS= read -r line; do
+      while IFS= read -r wt; do
+        if is_managed_file "$wt/$line"; then keep+="$line"$'\n'; break; fi
+      done < <(worktrees)
+    done < <(exclude_block_lines "$ex")
+    set_exclude_block "$ex" "${keep%$'\n'}"
+  fi
   say "removed managed registry config"
 }
 
 
@@ -10,7 +10,7 @@
 #     .npmrc (which can hold a registry credential) is not ignored. The exclude entries `link`
 #     adds live in one managed block, so `unlink` removes exactly that block (and nothing a
 #     user put in the file by hand), and a repeated `link` does not duplicate it. Unlinking one
-#     worktree keeps an entry another linked worktree of the same clone still needs.
+#     worktree or project keeps an entry another linked worktree or project still needs.
 # R3  a link/unlink round trip leaves a pom.xml that lacked a trailing newline byte-identical
 #     (the previous awk-based rewrites unconditionally added one), and `link`/`unlink` report
 #     "repinned ... in <file>" only for a pom whose own text actually changed — not a module
@@ -133,6 +133,27 @@ check "unlink removes the managed block from the shared exclude file" '! grep -q
 check "unlink removes the .npmrc entry it added" '! grep -qxF .npmrc "$common/info/exclude"'
 check "unlink leaves a user's own exclude rule alone" 'grep -qxF a-users-own-rule "$common/info/exclude"'
 
+# D11: two projects linked in ONE work tree share the block too, each entry named from the
+# repository root. Unlinking one keeps the entry the other's .npmrc still needs.
+multi="$WORK/multi"
+git init -q "$multi"
+mkdir -p "$multi/apps/web" "$multi/apps/api"
+for app in web api; do
+  printf '{ "name": "%s", "version": "1.0.0", "dependencies": { "@metaobjectsdev/metadata": "^1.0.0" } }\n' "$app" \
+    > "$multi/apps/$app/package.json"
+done
+git -C "$multi" add -A && git -C "$multi" commit -q -m init
+mcommon="$(git -C "$multi" rev-parse --git-common-dir)"
+case "$mcommon" in /*) ;; *) mcommon="$multi/$mcommon" ;; esac
+if link "$multi/apps/web" && link "$multi/apps/api"; then pass "link succeeds for two projects of one worktree"; else fail "link of two subprojects failed: $(tail -5 "$WORK/out")"; fi
+unlink_project "$multi/apps/web"
+check "unlinking one subproject removes its own .npmrc" '[ ! -f "$multi/apps/web/.npmrc" ]'
+check "unlinking one subproject drops its own exclude entry" '! grep -qxF apps/web/.npmrc "$mcommon/info/exclude"'
+check "the other subproject's .npmrc is still ignored by git" 'git -C "$multi" check-ignore -q -- apps/api/.npmrc'
+check "git status shows no .npmrc after one subproject is unlinked" '! git -C "$multi" status --porcelain | grep -q "\.npmrc"'
+unlink_project "$multi/apps/api"
+check "unlinking the last subproject removes the managed block" '! grep -q "metaobjects prerelease (managed)" "$mcommon/info/exclude"'
+
 # The assertion: an .npmrc git does not ignore makes link fail.
 git -C "$WORK/main" worktree add -q "$WORK/wt2" -b linked2
 # A global excludes file is not what we control, so defeat the ignore by negating it in .gitignore.
@@ -247,9 +268,11 @@ cat > "$poly/ports/csharp/.config/dotnet-tools.json" <<'JSON'
 { "version": 1, "isRoot": true, "tools": { "metaobjects.cli": { "commands": ["dotnet-meta"] } } }
 JSON
 git -C "$poly" add -A && git -C "$poly" commit -q -m init
+cp "$poly/ports/python/pyproject.toml" "$WORK/poly-pyproject.toml.orig"
 if link "$poly"; then pass "link succeeds in a polyglot repository"; else fail "polyglot link failed: $(tail -5 "$WORK/out")"; fi
 check "a manifest with no tool version reports that nothing was pinned" 'grep -q "ports/csharp/.config/dotnet-tools.json names MetaObjects.Cli but no version for it was found: nothing pinned" "$WORK/out" && ! grep -q "repinned MetaObjects.Cli to 1.1.0-rc.9 in ports/csharp/" "$WORK/out"'
 check "a repinned manifest is reported as repinned" 'grep -q "repinned MetaObjects.Cli to 1.1.0-rc.9 in .config/dotnet-tools.json" "$WORK/out"'
+check "link writes a NuGet.config at the root" 'grep -qF "metaobjects-prerelease" "$poly/NuGet.config"'
 check "the nested python project is linked" 'grep -q "metaobjects-prerelease" "$poly/ports/python/pyproject.toml"'
 check "the nested python project is repinned" 'grep -q "metaobjects==1.1.0rc9" "$poly/ports/python/pyproject.toml"'
 check "each independent pom gets the repositories" 'grep -q "<pluginRepositories>" "$poly/ports/java/pom.xml" && grep -q "<pluginRepositories>" "$poly/ports/kotlin/pom.xml"'
@@ -273,6 +296,10 @@ MO_REGISTRY_BASE="http://127.0.0.1:$PORT" MO_REGISTRY_OWNER=owner MO_REGISTRY_TO
   bash "$LINK" unlink --project "$poly" --to 1.0.13 >"$WORK/out" 2>&1 || true
 check "an inherited version property survives link and unlink" 'grep -q "<version>\${metaobjects.version}</version>" "$poly/ports/java/inherits/pom.xml" && ! grep -q "<version>8" "$poly/ports/java/inherits/pom.xml"'
 check "unlink removes every managed block" '! grep -rq "metaobjects prerelease (managed)" "$poly/ports"'
+check "the round trip leaves the pyproject.toml byte-identical (repin aside)" \
+  'sed "s/metaobjects==1.0.13/metaobjects==1.0.9/" "$poly/ports/python/pyproject.toml" | cmp -s - "$WORK/poly-pyproject.toml.orig"'
+check "unlink removes the NuGet.config link wrote" '[ ! -e "$poly/NuGet.config" ]'
+check "git status shows no NuGet.config after the round trip" '! git -C "$poly" status --porcelain | grep -q "NuGet.config"'
 check "unlink repins the nested python project" 'grep -q "metaobjects==1.0.13" "$poly/ports/python/pyproject.toml"'
 check "unlink repins every pom" 'grep -q "8.0.13" "$poly/ports/java/pom.xml" && grep -q "8.0.13" "$poly/ports/java/module/pom.xml" && [ "$(grep -c "<version>8.0.13</version>" "$poly/ports/kotlin/pom.xml")" = 3 ]'
 check "unlink repins the local tool" 'grep -q "\"metaobjects.cli\": { \"version\": \"1.0.13\"" "$poly/.config/dotnet-tools.json"'