fix(tmux): resolve send-message targets to an exact session and window

tmux resolves the two halves of a target with different, individually
dangerous defaults, and send-message.sh took both defaults:

  * An unpinned name PREFIX-matches. With `foobar` alive and no `foo`,
    `-t foo` resolves to `foobar` at rc=0 -- pasted, Enter-ed, verified
    and reported OK against the wrong agent's pane.
  * A bare `=name` is only half a pin. capture-pane REJECTS it ("can't
    find pane") while list-panes silently PREFIX-MATCHES it, and the
    validation at :76 uses list-panes -- so for any caller already
    supplying `=name`, that rewrite was the only thing between them and
    a wrong-session pass.

The direction is what makes this expensive. Paste (:93-94), Enter (:151)
and the verifying capture (:153) all read one EFFECTIVE_TARGET, so a
wrong-window send is confirmed by a wrong-window read: it manufactures a
false "delivered", not a loud failure. A false negative gets
investigated; a false positive gets believed.

Normalise to `=session:` -- exact session, active window. Explicit tmux
ids (%pane, @window, $session) pass through untouched.

BEHAVIOUR CHANGE for callers that already pass `=name`: they previously
landed on `:0.0` (window 0 unconditionally) and now land on the session's
ACTIVE window. This is the intended fix -- window 0 is not where a
multi-window agent is sitting -- but it does move a live target rather
than being a no-op normalisation.

Test: test-send-message-target.sh covers all four arms (absent name must
not prefix-match, delivery follows the active window, an explicit window
part is preserved, a unique prefix is still refused). Proven able to go
red: against the pre-fix script it FAILs at arm 1, and with arm 1 removed
it FAILs at arm 2. The multi-window fixture is load-bearing -- a
single-window session cannot tell `=s:` from `=s:0.0`, which is why this
survived.

It is registered as a signed enumeration exclusion rather than on a CI
surface: it drives a real tmux server and the CI image ships no tmux,
the same condition its two siblings are already excluded under. It
hard-fails when tmux is absent rather than skipping, so it cannot go
quietly green where it cannot run.

packages/mosaic/framework/tools/quality/test-enumeration-exclusions.txt

@@ -29,6 +29,10 @@ packages/mosaic/framework/tools/git/test-lane-brief-pr-linkage.sh | unmeasured i
 # --- tools/tmux: require a live tmux server ---
 packages/mosaic/framework/tools/tmux/test-send-message-socket.sh | requires a real tmux server on a throwaway socket; CI image ships no tmux; #1017 burndown (needs tmux in image or a signed permanent exclusion)
 packages/mosaic/framework/tools/tmux/test-send-message-verdict.sh | requires real tmux-pane fixtures on a throwaway socket; CI image ships no tmux; #1017 burndown (same condition as its sibling)
+# The entry below is NOT covered by the #1017 signature block above: it was
+# signed by jarvis-enhance (dragon-lin, 2026-08-24) at a later base, for the
+# test added alongside the send-message.sh exact-target fix.
+packages/mosaic/framework/tools/tmux/test-send-message-target.sh | requires a real tmux server on a throwaway socket, and specifically a MULTI-WINDOW session (the bug it guards is invisible on a single-window fixture); CI image ships no tmux; same burndown condition as its two siblings above
 
 # --- single-suite directories: unmeasured in CI ---
 

packages/mosaic/framework/tools/tmux/send-message.sh

@@ -64,13 +64,31 @@ if [ -n "$SOCKET_NAME" ]; then
   tmux_cmd+=(-L "$SOCKET_NAME")
 fi
 
-# tmux accepts `=session` for some commands, but pane-level commands such as
-# capture-pane require a pane-qualified target. Keep exact-session addressing
-# convenient while avoiding accidental prefix matches.
+# Normalise the target to an EXACT session plus a window part, because tmux
+# resolves the two halves with different and individually dangerous defaults:
+#
+#   * An unpinned name is a PREFIX match. With a session `foobar` alive and
+#     no session `foo`, `-t foo` resolves to `foobar` at rc=0, so a message is
+#     delivered, verified and reported OK against the wrong agent's pane.
+#   * A bare `=name` is not enough on its own: capture-pane REJECTS it
+#     ("can't find pane") while list-panes silently PREFIX-MATCHES it, so the
+#     validation below would pass on a session the capture cannot read.
+#   * A trailing `:` follows the session's ACTIVE window. Pinning `:0.0`
+#     instead addresses window 0 unconditionally, and since the paste, the
+#     Enter and the verifying capture all use EFFECTIVE_TARGET, a multi-window
+#     agent gets typed into window 0 and confirmed by reading window 0 --
+#     a false "delivered" rather than a loud failure.
+#
+# Explicit tmux ids (%pane, @window, $session) are passed through untouched;
+# prefixing `=` to them would break addressing that is already unambiguous.
 EFFECTIVE_TARGET=$TARGET
-if [[ "$TARGET" == =* && "$TARGET" != *:* ]]; then
-  EFFECTIVE_TARGET="${TARGET}:0.0"
-fi
+case "$TARGET" in
+  =*|%*|@*|\$*) ;;
+  *) EFFECTIVE_TARGET="=$TARGET" ;;
+esac
+case "$EFFECTIVE_TARGET" in
+  =*) [[ "$EFFECTIVE_TARGET" == *:* ]] || EFFECTIVE_TARGET="${EFFECTIVE_TARGET}:" ;;
+esac
 
 # Target must resolve to a live pane.
 if ! "${tmux_cmd[@]}" list-panes -t "$EFFECTIVE_TARGET" >/dev/null 2>&1; then

packages/mosaic/framework/tools/tmux/test-send-message-target.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+# Target normalisation: send-message.sh must address an EXACT session and the
+# session's ACTIVE window. Both halves have caused silent wrong-pane delivery:
+#   * an unpinned name prefix-matches, so a message for an absent session is
+#     delivered to a different agent and reported OK;
+#   * a `:0.0` pin addresses window 0 regardless of where the agent is, and
+#     because the paste, the Enter and the verifying capture share one target,
+#     the wrong window is also the window that confirms the send.
+# Both rows below FAIL against the pre-fix script, which is the point of them.
+set -euo pipefail
+
+SCRIPT_DIR=$(cd -- "$(dirname -- "$0")" && pwd)
+SEND_MESSAGE="$SCRIPT_DIR/send-message.sh"
+SOCKET="mosaic-test-target-$RANDOM-$$"
+TMPDIR=$(mktemp -d)
+trap 'tmux -L "$SOCKET" kill-server >/dev/null 2>&1 || true; rm -rf "$TMPDIR"' EXIT
+
+fail() { echo "FAIL: $*" >&2; exit 1; }
+command -v tmux >/dev/null 2>&1 || fail "tmux is required"
+
+tmux_() { tmux -L "$SOCKET" "$@"; }
+newsess() { tmux_ new-session -d -s "$1" -c "$TMPDIR" 'PS1="❯ " exec bash --noprofile --norc -i'; }
+hits() { tmux_ capture-pane -p -t "$1" 2>/dev/null | grep -cF "$2" || true; }
+
+# ── 1. an absent session must not prefix-match a live one ───────────────────
+newsess sibling-long
+nonce="absent-target-$RANDOM"
+rc=0; "$SEND_MESSAGE" -L "$SOCKET" -t sibling -m "$nonce" >/dev/null 2>&1 || rc=$?
+[ "$rc" -ne 0 ] || fail "send to absent session 'sibling' returned rc=0 (prefix-matched)"
+[ "$(hits sibling-long "$nonce")" -eq 0 ] || fail "message for absent 'sibling' was delivered to 'sibling-long'"
+
+# positive control: the detector above can see a real delivery
+nonce_ok="control-$RANDOM"
+"$SEND_MESSAGE" -L "$SOCKET" -t sibling-long -m "$nonce_ok" >/dev/null 2>&1 \
+  || fail "send to a live session failed"
+[ "$(hits sibling-long "$nonce_ok")" -gt 0 ] || fail "control: live delivery not observed — detector is blind"
+
+# ── 2. delivery follows the ACTIVE window, not window 0 ─────────────────────
+# A single-window fixture cannot tell `=s:` from `=s:0.0`; the active window
+# must be non-zero or this test proves nothing.
+newsess multi
+tmux_ new-window -t multi -c "$TMPDIR" 'PS1="❯ " exec bash --noprofile --norc -i'
+tmux_ select-window -t multi:1
+active=$(tmux_ display-message -p -t multi '#{window_index}')
+[ "$active" = "1" ] || fail "fixture setup: expected active window 1, got $active"
+
+for target in multi "=multi"; do
+  nonce="active-win-$RANDOM"
+  "$SEND_MESSAGE" -L "$SOCKET" -t "$target" -m "$nonce" >/dev/null 2>&1 \
+    || fail "send to '$target' failed"
+  [ "$(hits multi:1 "$nonce")" -gt 0 ] || fail "'$target' did not deliver to the active window"
+  [ "$(hits multi:0 "$nonce")" -eq 0 ] || fail "'$target' delivered to window 0 instead of the active window"
+done
+
+# ── 3. an explicit window part is preserved ─────────────────────────────────
+nonce="explicit-win-$RANDOM"
+"$SEND_MESSAGE" -L "$SOCKET" -t multi:0 -m "$nonce" >/dev/null 2>&1 || fail "send to 'multi:0' failed"
+[ "$(hits multi:0 "$nonce")" -gt 0 ] || fail "explicit 'multi:0' did not deliver to window 0"
+
+# ── 4. a unique prefix of a live session is still refused ───────────────────
+nonce="prefix-$RANDOM"
+rc=0; "$SEND_MESSAGE" -L "$SOCKET" -t mult -m "$nonce" >/dev/null 2>&1 || rc=$?
+[ "$rc" -ne 0 ] || fail "send to prefix 'mult' returned rc=0"
+[ "$(hits multi:1 "$nonce")" -eq 0 ] || fail "prefix 'mult' was delivered to 'multi'"
+
+echo "PASS: send-message.sh target normalisation"

packages/mosaic/src/fleet/comms-onboarding.spec.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import {
   chmodSync,
   mkdtempSync,
@@ -16,7 +16,6 @@ import {
   renderPeerReach,
   readFleetCommsBlock,
   resolveCommsBlock,
-  resolveFleetIdentity,
   resolvePeerCommand,
   renderToolsContractStatus,
 } from './comms-onboarding.js';
@@ -62,68 +61,6 @@ describe('shared fleet roster v1 resolver', () => {
     });
   });
 
-  // stack#1380 verification unblock: the fleet's own roster-v2 tooling writes
-  // the v1 body plus a generation fence and seat lifecycle/launch envelopes.
-  // The parser tolerates exactly that envelope (validated, opaque to comms).
-  const V2_ROSTER = [
-    'version: 2',
-    'generation: 8',
-    'transport: tmux',
-    'tmux:',
-    '  socket_name: mosaic-fleet',
-    'defaults:',
-    '  working_directory: ~/.mosaic',
-    '  runtime: claude',
-    'agents:',
-    '  - name: orch-01',
-    '    runtime: claude',
-    '    class: orchestrator',
-    '    model: opus',
-    '    reasoning: high',
-    '    lifecycle:',
-    '      enabled: true',
-    '      desired_state: running',
-    '    launch:',
-    '      yolo: false',
-    '',
-  ].join('\n');
-
-  it('accepts the roster-v2 envelope (generation + lifecycle/launch) on the v1 body', () => {
-    const resolved = parseFleetRosterV1(V2_ROSTER, 'yaml');
-    expect(resolved.tmux.socketName).toBe('mosaic-fleet');
-    expect(resolved.agents[0]?.name).toBe('orch-01');
-  });
-
-  it('rejects a non-integer generation', () => {
-    expect(() =>
-      parseFleetRosterV1(V2_ROSTER.replace('generation: 8', 'generation: eight'), 'yaml'),
-    ).toThrow(/generation must be a non-negative integer/);
-  });
-
-  it('rejects an invalid lifecycle desired_state', () => {
-    expect(() =>
-      parseFleetRosterV1(
-        V2_ROSTER.replace('desired_state: running', 'desired_state: paused'),
-        'yaml',
-      ),
-    ).toThrow(/desired_state must be running\|stopped/);
-  });
-
-  it('rejects unknown fields inside the lifecycle envelope', () => {
-    expect(() =>
-      parseFleetRosterV1(
-        V2_ROSTER.replace('      enabled: true', '      enabled: true\n      surprise: 1'),
-        'yaml',
-      ),
-    ).toThrow(/lifecycle has unknown field/);
-  });
-
-  it('rejects a non-boolean launch.yolo', () => {
-    expect(() =>
-      parseFleetRosterV1(V2_ROSTER.replace('yolo: false', 'yolo: sometimes'), 'yaml'),
-    ).toThrow(/launch\.yolo must be a boolean/);
-  });
-
   it('rejects unknown fields instead of leniently constructing a second roster view', () => {
     expect(() => parseFleetRosterV1(`${ROSTER}\nunknown: value\n`, 'yaml')).toThrow(
       /unknown field/i,
@@ -556,11 +493,6 @@ describe('resolvePeerCommand', () => {
 describe('readFleetCommsBlock — spawned-agent context', () => {
   let home: string;
   beforeEach(() => {
-    // Hermetic helper fallback (stack#1380): the resolver probes
-    // $HOME/.config/mosaic when mosaicHome itself carries no helper — point
-    // HOME at a sandbox parent so tests never see the real host install.
-    vi.stubEnv('HOME', mkdtempSync(join(tmpdir(), 'mosaic-homeless-')));
-    vi.stubEnv('MOSAIC_HOME', '');
     home = mkdtempSync(join(tmpdir(), 'mosaic-comms-'));
     mkdirSync(join(home, 'fleet'), { recursive: true });
     mkdirSync(join(home, 'tools', 'tmux'), { recursive: true });
@@ -569,10 +501,7 @@ describe('readFleetCommsBlock — spawned-agent context', () => {
     writeFileSync(helper, '#!/bin/sh\n');
     chmodSync(helper, 0o755);
   });
-  afterEach(() => {
-    vi.unstubAllEnvs();
-    rmSync(home, { recursive: true, force: true });
-  });
+  afterEach(() => rmSync(home, { recursive: true, force: true }));
 
   it('uses the authoritative self host and global socket from the shared roster resolver', () => {
     const result = readFleetCommsBlock(home, 'enhancer', 'process-host-must-not-win');
@@ -635,27 +564,23 @@ describe('readFleetCommsBlock — spawned-agent context', () => {
       },
     ],
     [
-      'symlink escaping the install home',
+      'symlink',
       () => {
         const helper = join(home, 'tools', 'tmux', 'agent-send.sh');
         rmSync(helper);
-        const outside = mkdtempSync(join(tmpdir(), 'mosaic-helper-outside-'));
-        writeFileSync(join(outside, 'real-send.sh'), '#!/bin/sh\n', { mode: 0o755 });
-        symlinkSync(join(outside, 'real-send.sh'), helper);
+        writeFileSync(join(home, 'real-send.sh'), '#!/bin/sh\n');
+        symlinkSync(join(home, 'real-send.sh'), helper);
       },
     ],
     ['non-executable', () => chmodSync(join(home, 'tools', 'tmux', 'agent-send.sh'), 0o644)],
-  ])(
-    'fails closed for a %s helper with deterministic guidance (no forbidden remedy)',
-    (_case, mutate) => {
-      mutate();
-      const result = readFleetCommsBlock(home, 'enhancer', 'w-jarvis');
-      expect(result.ok).toBe(false);
-      expect(result.output).toBe('');
-      expect(result.error).not.toContain('--repair-tools'); // stack#1380 M5a
-      expect(result.error).toContain('no active context or session was rewritten');
-    },
-  );
+  ])('fails closed for a %s helper with deterministic repair guidance', (_case, mutate) => {
+    mutate();
+    const result = readFleetCommsBlock(home, 'enhancer', 'w-jarvis');
+    expect(result.ok).toBe(false);
+    expect(result.output).toBe('');
+    expect(result.error).toContain('mosaic update --repair-tools');
+    expect(result.error).toContain('no active context or session was rewritten');
+  });
 
   it('does not rewrite the roster while resolving context', () => {
     const path = join(home, 'fleet', 'roster.yaml');
@@ -678,11 +603,11 @@ describe('renderToolsContractStatus — non-mutating install drift', () => {
   });
   afterEach(() => rmSync(home, { recursive: true, force: true }));
 
-  it('names operator-verified recovery instead of a forbidden remedy when installed TOOLS.md is missing', () => {
+  it('uses the supported repair command when installed TOOLS.md is missing', () => {
     const status = renderToolsContractStatus(home);
-    expect(status).toContain('authorized operator');
-    expect(status).not.toContain('--repair-tools'); // stack#1380 M5a
+    expect(status).toContain('mosaic update --repair-tools');
     expect(status).not.toContain('--reseed');
+    expect(status).toContain('authorized operator');
   });
 
   it('reports stale preserved content without rewriting it', () => {
@@ -691,8 +616,8 @@ describe('renderToolsContractStatus — non-mutating install drift', () => {
     writeFileSync(path, stale);
     const status = renderToolsContractStatus(home);
     expect(status).toContain('fleet-comms-contract: 1');
-    expect(status).toContain('authorized operator');
-    expect(status).not.toContain('--repair-tools'); // stack#1380 M5a
+    expect(status).toContain('digest-qualified backup');
+    expect(status).toContain('mosaic update --repair-tools');
     expect(status).toContain('active context was not rewritten');
     expect(readFileSync(path, 'utf8')).toBe(stale);
   });
@@ -723,7 +648,7 @@ describe('renderToolsContractStatus — non-mutating install drift', () => {
     expect(renderToolsContractStatus(home)).not.toBe('');
   });
 
-  it('reads an installed TOOLS.md symlink whose validated target diverges (stack#1380 resolve-then-validate)', () => {
+  it('treats installed TOOLS.md symlinks as stale without following or rewriting them', () => {
     const external = join(home, 'external-tools.md');
     const externalContent = '# external\n<!-- fleet-comms-contract: 1 -->\n';
     writeFileSync(external, externalContent);
@@ -731,23 +656,24 @@ describe('renderToolsContractStatus — non-mutating install drift', () => {
 
     const status = renderToolsContractStatus(home);
 
-    expect(status).toContain('does not byte-match');
+    expect(status).toContain('unavailable');
+    expect(status).toContain('mosaic update --repair-tools');
     expect(readFileSync(external, 'utf8')).toBe(externalContent);
   });
 
-  it('treats a source TOOLS.md symlink escaping the install home as unavailable', () => {
-    const outside = mkdtempSync(join(tmpdir(), 'mosaic-source-outside-'));
+  it('treats source TOOLS.md symlinks as unavailable without following them', () => {
+    const external = join(home, 'external-source.md');
     const content = '# authoritative tools\n<!-- fleet-comms-contract: 1 -->\n';
-    writeFileSync(join(outside, 'external-source.md'), content);
+    writeFileSync(external, content);
     rmSync(join(home, 'defaults', 'TOOLS.md'));
-    symlinkSync(join(outside, 'external-source.md'), join(home, 'defaults', 'TOOLS.md'));
+    symlinkSync(external, join(home, 'defaults', 'TOOLS.md'));
     writeFileSync(join(home, 'TOOLS.md'), content);
 
     const status = renderToolsContractStatus(home);
 
     expect(status).toContain('source contract');
     expect(status).toContain('unavailable');
-    expect(readFileSync(join(outside, 'external-source.md'), 'utf8')).toBe(content);
+    expect(readFileSync(external, 'utf8')).toBe(content);
   });
 
   it('accepts byte-equal bounded source and installed contracts', () => {
@@ -804,91 +730,3 @@ describe('resolveCommsBlock — mosaic agent comms-block', () => {
     expect(result.error).toContain('requires');
   });
 });
-
-describe('resolveFleetIdentity — stack#1380 split-home layouts', () => {
-  // Brain-shaped mosaicHome (fleet state, NO tools/tmux) + framework config
-  // home carrying the helper, roster unified by the framework-created symlink
-  // <configHome>/fleet/roster.yaml -> <brain>/fleet/roster.yaml. This is the
-  // host layout that was down; all probes are POSITIONAL per the #1380
-  // verification protocol (an object arg proves nothing — M5b). HOME is
-  // stubbed so the config-default fallback stays inside the sandbox.
-  let brain: string;
-  let configHome: string;
-
-  beforeEach(() => {
-    const parent = mkdtempSync(join(tmpdir(), 'mosaic-i1380-parent-'));
-    brain = join(parent, 'brain');
-    // Framework home at the stubbed DEFAULT location so the fallback derives
-    // exactly as in production ($HOME/.config/mosaic), not by coincidence.
-    configHome = join(parent, 'home', '.config', 'mosaic');
-    vi.stubEnv('HOME', join(parent, 'home'));
-    vi.stubEnv('MOSAIC_HOME', '');
-    mkdirSync(join(brain, 'fleet'), { recursive: true });
-    writeFileSync(join(brain, 'fleet', 'roster.yaml'), ROSTER, { mode: 0o600 });
-    mkdirSync(join(configHome, 'fleet'), { recursive: true });
-    symlinkSync(join(brain, 'fleet', 'roster.yaml'), join(configHome, 'fleet', 'roster.yaml'));
-    mkdirSync(join(configHome, 'tools', 'tmux'), { recursive: true });
-    writeFileSync(join(configHome, 'tools', 'tmux', 'agent-send.sh'), '#!/bin/sh\n', {
-      mode: 0o755,
-    });
-    process.env['MOSAIC_BRAIN_HOME'] = brain;
-  });
-
-  afterEach(() => {
-    delete process.env['MOSAIC_BRAIN_HOME'];
-    vi.unstubAllEnvs();
-    rmSync(join(brain, '..'), { recursive: true, force: true });
-  });
-
-  it('resolves a member through the roster symlink under the config home', () => {
-    const result = resolveFleetIdentity(configHome, 'orchestrator', 'w-jarvis');
-    expect(result.ok).toBe(true);
-    expect(result.identity?.member.name).toBe('orchestrator');
-    expect(result.identity?.agentSendPath).toBe(join(configHome, 'tools', 'tmux', 'agent-send.sh'));
-  });
-
-  it('resolves a member when mosaicHome is the brain (helper found under the framework home)', () => {
-    const result = resolveFleetIdentity(brain, 'enhancer', 'w-jarvis');
-    expect(result.ok).toBe(true);
-    expect(result.identity?.member.name).toBe('enhancer');
-    expect(result.identity?.agentSendPath).toBe(join(configHome, 'tools', 'tmux', 'agent-send.sh'));
-  });
-
-  it('no-name control stays a quiet no-op', () => {
-    expect(resolveFleetIdentity(configHome, undefined, 'w-jarvis')).toEqual({ ok: true });
-    expect(resolveFleetIdentity(brain, undefined, 'w-jarvis')).toEqual({ ok: true });
-  });
-
-  it('a nonce name fails naming membership, not the symlink or the helper', () => {
-    const result = resolveFleetIdentity(configHome, 'nonce-' + Date.now(), 'w-jarvis');
-    expect(result.ok).toBe(false);
-    expect(result.error).not.toContain('symbolic link');
-    expect(result.error).not.toContain('helper');
-    expect(result.error).toContain('nonce-');
-  });
-
-  it('a non-member failure names membership, not the symlink (protocol control)', () => {
-    const result = resolveFleetIdentity(configHome, 'jarvis', 'w-jarvis');
-    expect(result.ok).toBe(false);
-    expect(result.error).not.toContain('symbolic link');
-    expect(result.error).not.toContain('helper is unavailable');
-    expect(result.error).toContain('orchestrator'); // known-member listing
-  });
-
-  it('names every searched framework home when the helper is missing everywhere', () => {
-    rmSync(join(configHome, 'tools'), { recursive: true, force: true });
-    const result = resolveFleetIdentity(brain, 'orchestrator', 'w-jarvis');
-    expect(result.ok).toBe(false);
-    expect(result.error).toContain('agent-send.sh');
-    expect(result.error).toContain(join(brain, 'tools', 'tmux', 'agent-send.sh'));
-    expect(result.error).not.toContain('--repair-tools');
-  });
-
-  it('readFleetCommsBlock composes the full contract on the split-home layout', () => {
-    const result = readFleetCommsBlock(configHome, 'orchestrator', 'w-jarvis');
-    expect(result.ok).toBe(true);
-    expect(result.output).toContain(
-      'Helper: `' + join(configHome, 'tools', 'tmux', 'agent-send.sh'),
-    );
-  });
-});

packages/mosaic/src/fleet/comms-onboarding.ts

@@ -9,9 +9,8 @@
 import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { homedir, hostname } from 'node:os';
-import { join, resolve } from 'node:path';
+import { join } from 'node:path';
 import { readRegularFileSecure } from './secure-file.js';
-import { resolveBrainHome } from './brain-home.js';
 import {
   parseFleetRosterV1,
   resolveInstalledFleetRosterPath,
@@ -261,13 +260,7 @@ context and have an authorized operator relaunch only this exact roster member w
 
 function validateAgentSendHelper(path: string, mosaicHome: string): string | undefined {
   try {
-    readRegularFileSecure(path, {
-      root: mosaicHome,
-      executable: true,
-      // The helper tree may live under the framework config home while this
-      // caller's mosaicHome is the brain; both are framework-owned roots.
-      symlinkTargetRoots: [resolveBrainHome(mosaicHome)],
-    });
+    readRegularFileSecure(path, { root: mosaicHome, executable: true });
     return undefined;
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
@@ -275,48 +268,8 @@ function validateAgentSendHelper(path: string, mosaicHome: string): string | und
   }
 }
 
-/**
- * Framework install homes probed for tools/tmux/agent-send.sh (stack#1380 M2).
- * The helper ships with the FRAMEWORK install, which on split-home layouts is
- * the config home — not the brain (~/.mosaic carries fleet state, no tools).
- */
-function frameworkHelperHomes(mosaicHome: string): string[] {
-  const homes = [resolve(mosaicHome)];
-  const envHome = process.env['MOSAIC_HOME'];
-  if (envHome && envHome.trim() !== '' && resolve(envHome) !== resolve(mosaicHome)) {
-    homes.push(resolve(envHome));
-  }
-  const configDefault = join(homedir(), '.config', 'mosaic');
-  if (resolve(configDefault) !== resolve(mosaicHome)) homes.push(configDefault);
-  return homes;
-}
-
-function resolveAgentSendHelper(mosaicHome: string): { path: string; error?: string } {
-  const homes = frameworkHelperHomes(mosaicHome);
-  for (const home of homes) {
-    const helper = join(home, 'tools', 'tmux', 'agent-send.sh');
-    if (!existsSync(helper)) continue;
-    const error = validateAgentSendHelper(helper, home);
-    if (!error) return { path: helper };
-    // Present but unsafe: surface that verdict instead of silently probing on.
-    return { path: helper, error };
-  }
-  return {
-    path: join(resolve(mosaicHome), 'tools', 'tmux', 'agent-send.sh'),
-    error:
-      `fleet helper agent-send.sh was not found under any framework install home ` +
-      `(${homes.map((h) => join(h, 'tools', 'tmux', 'agent-send.sh')).join('; ')}). ` +
-      `Verify the framework install for this host (the helper ships with the framework ` +
-      `config home; the brain home carries fleet state, not tools) and have an authorized ` +
-      `operator restore it if missing.`,
-  };
-}
-
 function helperFailureGuidance(reason: string): string {
-  // stack#1380 M5a: `mosaic update --repair-tools` is a forbidden remedy on the
-  // affected estate (and wrong for a layout/missing-helper failure). Name the
-  // actual recovery shape instead.
-  return `${reason}. Verify the framework install provides tools/tmux/agent-send.sh under the framework config home and that the roster resolves (split-home layouts symlink the roster into the brain); contact the operator if it persists; no active context or session was rewritten.`;
+  return `${reason}. Run \`mosaic update --repair-tools\` to restore the supported current-version helper and TOOLS contract, then retry exact-member composition; no active context or session was rewritten.`;
 }
 
 export function resolveFleetIdentity(
@@ -325,15 +278,9 @@ export function resolveFleetIdentity(
   localHost: string = shortHostname(),
 ): FleetIdentityResult {
   if (!requestedName) return { ok: true };
-  const helper = resolveAgentSendHelper(mosaicHome);
-  if (helper.error) return { ok: false, error: helperFailureGuidance(helper.error) };
-  const agentSendPath = helper.path;
-
-  // Split-home layouts unify the roster by symlinking
-  // <configHome>/fleet/roster.yaml -> <brain>/fleet/roster.yaml. The secure
-  // read resolves that framework-created symlink when the brain is a
-  // sanctioned target root (stack#1380 M1).
-  const rosterSymlinkRoots = [resolveBrainHome(mosaicHome)];
+  const agentSendPath = join(mosaicHome, 'tools', 'tmux', 'agent-send.sh');
+  const helperError = validateAgentSendHelper(agentSendPath, mosaicHome);
+  if (helperError) return { ok: false, error: helperFailureGuidance(helperError) };
 
   let rosterPath: string;
   try {
@@ -354,10 +301,7 @@ export function resolveFleetIdentity(
   let roster: FleetRoster;
   try {
     roster = parseFleetRosterV1(
-      readRegularFileSecure(rosterPath, {
-        root: mosaicHome,
-        symlinkTargetRoots: rosterSymlinkRoots,
-      }).content.toString('utf8'),
+      readRegularFileSecure(rosterPath, { root: mosaicHome }).content.toString('utf8'),
       rosterPath.endsWith('.json') ? 'json' : 'yaml',
     );
   } catch (error) {
@@ -455,9 +399,7 @@ function boundedContractDigest(
 }
 
 function replacementGuidance(): string {
-  // stack#1380 M5a: never recommend the forbidden --repair-tools remedy from
-  // error text; name the operator-verified recovery shape instead.
-  return `Verify the installed TOOLS contract against the framework source with an authorized operator (the installed file must byte-match the supported current version) and have the operator explicitly relaunch the exact roster member. The active context was not rewritten.`;
+  return `Run \`mosaic update --repair-tools\` to make a digest-qualified backup and restore the supported current-version TOOLS contract, then have an authorized operator explicitly relaunch the exact roster member. The active context was not rewritten.`;
 }
 
 /** Detect preserved installed TOOLS.md drift without changing it. */

packages/mosaic/src/fleet/fleet-roster-v1.ts

@@ -7,7 +7,6 @@ import { canonicalizeRoleClass } from '../commands/fleet-personas.js';
 interface RawFleetRoster {
   version?: unknown;
   transport?: unknown;
-  generation?: unknown;
   tmux?: {
     socket_name?: unknown;
     socketName?: unknown;
@@ -42,10 +41,6 @@ interface RawFleetRoster {
     resetBetweenTasks?: unknown;
     kickstart_template?: unknown;
     kickstartTemplate?: unknown;
-    model?: unknown;
-    reasoning?: unknown;
-    lifecycle?: { enabled?: unknown; desired_state?: unknown };
-    launch?: { yolo?: unknown };
   }>;
   connector?: {
     kind?: unknown;
@@ -221,17 +216,7 @@ function normalizeFleetRosterV1Unchecked(raw: RawFleetRoster): FleetRoster {
     'runtimes',
     'agents',
     'connector',
-    // stack#1380 verification unblock: the fleet's own roster-v2 mutation
-    // tooling writes a `generation` fence on the same v1 body. Tolerated here
-    // as an opaque non-negative integer; comms semantics are unchanged.
-    'generation',
   ]);
-  if (
-    raw.generation !== undefined &&
-    (typeof raw.generation !== 'number' || !Number.isInteger(raw.generation) || raw.generation < 0)
-  ) {
-    throw new Error('Fleet roster generation must be a non-negative integer.');
-  }
   if (raw.tmux !== undefined) {
     assertObject(raw.tmux, 'Fleet roster tmux');
     assertKnownKeys(raw.tmux, 'Fleet roster tmux', [
@@ -246,8 +231,6 @@ function normalizeFleetRosterV1Unchecked(raw: RawFleetRoster): FleetRoster {
     assertKnownKeys(raw.defaults, 'Fleet roster defaults', [
       'working_directory',
       'workingDirectory',
-      // stack#1380 verification unblock: roster-v2 default runtime hint.
-      'runtime',
     ]);
   }
   if (raw.runtimes !== undefined) {
@@ -260,9 +243,7 @@ function normalizeFleetRosterV1Unchecked(raw: RawFleetRoster): FleetRoster {
       ]);
     }
   }
-  if (raw.version !== 1 && raw.version !== 2) {
-    throw new Error('Fleet roster version must be 1 or 2.');
-  }
+  if (raw.version !== 1) throw new Error('Fleet roster version must be 1.');
   if (raw.transport !== 'tmux') throw new Error('Fleet roster transport must be "tmux".');
   if (!Array.isArray(raw.agents) || raw.agents.length === 0) {
     throw new Error('Fleet roster must define at least one agent.');
@@ -337,52 +318,7 @@ function normalizeAgent(raw: NonNullable<RawFleetRoster['agents']>[number]): Fle
     'resetBetweenTasks',
     'kickstart_template',
     'kickstartTemplate',
-    // stack#1380 verification unblock: roster-v2 envelope fields written by
-    // the fleet's own mutation tooling. Validated, then opaque to comms.
-    'model',
-    'reasoning',
-    'lifecycle',
-    'launch',
   ]);
-  if (raw.model !== undefined && typeof raw.model !== 'string') {
-    throw new Error('Fleet roster agent model must be a string.');
-  }
-  if (raw.reasoning !== undefined && typeof raw.reasoning !== 'string') {
-    throw new Error('Fleet roster agent reasoning must be a string.');
-  }
-  const lifecycle = raw.lifecycle as { enabled?: unknown; desired_state?: unknown } | undefined;
-  if (lifecycle !== undefined) {
-    if (typeof lifecycle !== 'object' || lifecycle === null) {
-      throw new Error('Fleet roster agent lifecycle must be an object.');
-    }
-    const lifecycleKeys = Object.keys(lifecycle);
-    if (!lifecycleKeys.every((key) => key === 'enabled' || key === 'desired_state')) {
-      throw new Error('Fleet roster agent lifecycle has unknown field(s).');
-    }
-    if (lifecycle.enabled !== undefined && typeof lifecycle.enabled !== 'boolean') {
-      throw new Error('Fleet roster agent lifecycle.enabled must be a boolean.');
-    }
-    if (
-      lifecycle.desired_state !== undefined &&
-      (typeof lifecycle.desired_state !== 'string' ||
-        !['running', 'stopped'].includes(lifecycle.desired_state))
-    ) {
-      throw new Error('Fleet roster agent lifecycle.desired_state must be running|stopped.');
-    }
-  }
-  const launch = raw.launch as { yolo?: unknown } | undefined;
-  if (launch !== undefined) {
-    if (typeof launch !== 'object' || launch === null) {
-      throw new Error('Fleet roster agent launch must be an object.');
-    }
-    const launchKeys = Object.keys(launch);
-    if (!launchKeys.every((key) => key === 'yolo')) {
-      throw new Error('Fleet roster agent launch has unknown field(s).');
-    }
-    if (launch.yolo !== undefined && typeof launch.yolo !== 'boolean') {
-      throw new Error('Fleet roster agent launch.yolo must be a boolean.');
-    }
-  }
   const name = stringValue(raw.name, '', 'Fleet roster agent name');
   const runtime = stringValue(
     raw.runtime,

packages/mosaic/src/fleet/secure-file.spec.ts

@@ -10,14 +10,12 @@ import {
   type PathLike,
 } from 'node:fs';
 import type * as NodeFs from 'node:fs';
-import type { Stats } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
+import { join } from 'node:path';
 
 interface FilesystemRaceState {
   afterLstat?: (path: string) => void;
   afterOpen?: (path: string) => void;
-  afterStat?: (path: string, stats: Stats) => Stats;
 }
 
 const filesystemRaceState = vi.hoisted<FilesystemRaceState>(() => ({}));
@@ -31,10 +29,6 @@ vi.mock('node:fs', async (importOriginal) => {
       filesystemRaceState.afterLstat?.(String(path));
       return result;
     },
-    statSync: (path: PathLike) => {
-      const result = actual.statSync(path);
-      return filesystemRaceState.afterStat?.(String(path), result) ?? result;
-    },
     openSync: (path: PathLike, flags: string | number, mode?: number) => {
       const fd = actual.openSync(path, flags, mode);
       filesystemRaceState.afterOpen?.(String(path));
@@ -52,13 +46,11 @@ describe('secure file reads', () => {
     root = mkdtempSync(join(tmpdir(), 'mosaic-secure-file-'));
     filesystemRaceState.afterLstat = undefined;
     filesystemRaceState.afterOpen = undefined;
-    filesystemRaceState.afterStat = undefined;
   });
 
   afterEach(() => {
     filesystemRaceState.afterLstat = undefined;
     filesystemRaceState.afterOpen = undefined;
-    filesystemRaceState.afterStat = undefined;
     rmSync(root, { recursive: true, force: true });
   });
 
@@ -68,87 +60,25 @@ describe('secure file reads', () => {
     );
   });
 
-  // stack#1380: the guard resolves symlinks and validates the resolved target
-  // instead of refusing any symlink component.
-  it('permits a symlink ancestor whose resolved target is inside the root', () => {
+  it('rejects a symlink in a file ancestor', () => {
     const external = join(root, 'external');
     mkdirSync(external);
     writeFileSync(join(external, 'file'), 'external\n');
     symlinkSync(external, join(root, 'linked'));
 
-    const snapshot = readRegularFileSecure(join(root, 'linked', 'file'), { root });
-    expect(snapshot.content.toString('utf8')).toBe('external\n');
-  });
-
-  it('permits a symlinked file whose resolved target is inside the root', () => {
-    const external = join(root, 'external-file');
-    writeFileSync(external, 'external\n');
-    symlinkSync(external, join(root, 'linked-file'));
-
-    const snapshot = readRegularFileSecure(join(root, 'linked-file'), { root });
-    expect(snapshot.content.toString('utf8')).toBe('external\n');
-  });
-
-  it('permits a symlink resolving into an additional sanctioned root (split-home roster shape)', () => {
-    const brain = `${root}-brain`;
-    mkdirSync(join(brain, 'fleet'), { recursive: true });
-    writeFileSync(join(brain, 'fleet', 'roster.yaml'), 'roster\n', { mode: 0o600 });
-    mkdirSync(join(root, 'fleet'));
-    symlinkSync(join(brain, 'fleet', 'roster.yaml'), join(root, 'fleet', 'roster.yaml'));
-
-    const snapshot = readRegularFileSecure(join(root, 'fleet', 'roster.yaml'), {
-      root,
-      symlinkTargetRoots: [brain],
-    });
-    expect(snapshot.content.toString('utf8')).toBe('roster\n');
-  });
-
-  it('refuses a symlink whose resolved target escapes every sanctioned root', () => {
-    const outside = mkdtempSync(join(tmpdir(), 'mosaic-secure-outside-'));
-    try {
-      mkdirSync(join(root, 'fleet'), { recursive: true });
-      writeFileSync(join(outside, 'roster.yaml'), 'escaped\n', { mode: 0o600 });
-      symlinkSync(join(outside, 'roster.yaml'), join(root, 'fleet', 'roster.yaml'));
-
-      expect(() => readRegularFileSecure(join(root, 'fleet', 'roster.yaml'), { root })).toThrow(
-        /symlink target escapes managed roots/,
-      );
-    } finally {
-      rmSync(outside, { recursive: true, force: true });
-    }
-  });
-
-  it('refuses a group-writable symlink target', () => {
-    const loose = join(root, 'loose');
-    mkdirSync(loose);
-    chmodSync(loose, 0o770); // group-writable bit survives umask via explicit chmod
-    writeFileSync(join(loose, 'file'), 'loose\n');
-    symlinkSync(loose, join(root, 'linked-loose'));
-
-    expect(() => readRegularFileSecure(join(root, 'linked-loose', 'file'), { root })).toThrow(
-      /group- or world-writable/,
+    expect(() => readRegularFileSecure(join(root, 'linked', 'file'), { root })).toThrow(
+      'path ancestor is a symbolic link',
     );
   });
 
-  it('refuses a symlink target owned by another user', () => {
-    const external = join(root, 'foreign');
-    mkdirSync(external);
-    writeFileSync(join(external, 'file'), 'foreign\n');
-    symlinkSync(external, join(root, 'linked-foreign'));
+  it('rejects a symlink target', () => {
+    const external = join(root, 'external');
+    writeFileSync(external, 'external\n');
+    symlinkSync(external, join(root, 'linked-file'));
 
-    filesystemRaceState.afterStat = (path, stats): Stats => {
-      if (resolve(path) === resolve(external)) {
-        return { ...stats, uid: stats.uid + 4242 } as Stats;
-      }
-      return stats;
-    };
-    try {
-      expect(() => readRegularFileSecure(join(root, 'linked-foreign', 'file'), { root })).toThrow(
-        /not owned by the current user/,
-      );
-    } finally {
-      filesystemRaceState.afterStat = undefined;
-    }
+    expect(() => readRegularFileSecure(join(root, 'linked-file'), { root })).toThrow(
+      'file is a symbolic link',
+    );
   });
 
   it('keeps ancestor traversal bound when an opened directory is substituted', () => {

packages/mosaic/src/fleet/secure-file.ts

@@ -7,25 +7,14 @@ import {
   mkdirSync,
   openSync,
   readFileSync,
-  readlinkSync,
-  statSync,
 } from 'node:fs';
 import { platform } from 'node:os';
-import { basename, dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
 
 export interface SecureFileReadOptions {
   root: string;
   maxBytes?: number;
   executable?: boolean;
-  /**
-   * Additional roots a symlink component may resolve into (stack#1380).
-   * Default: only the managed root itself. Every symlink hop is validated —
-   * containment under the root or one of these roots, current-user ownership,
-   * no group/world-writable mode — and refusal stays the default for anything
-   * else. Callers that operate the split-home layout pass the brain home so
-   * the framework-created roster symlink resolves.
-   */
-  symlinkTargetRoots?: string[];
 }
 
 export interface SecureFileSnapshot {
@@ -99,57 +88,7 @@ function openDirectoryChain(absoluteDirectory: string): { fd: number; descriptor
   }
 }
 
-function containedUnder(root: string, target: string): boolean {
-  const rel = relative(resolve(root), resolve(target));
-  return rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel) && rel !== '';
-}
-
-const MAX_SYMLINK_HOPS = 40;
-
-/**
- * Resolve every symlink on `lexical` component-wise, validating each hop
- * (stack#1380 resolve-then-validate): the hop target must stay under one of
- * the sanctioned roots, must be owned by the current user (or root), and must
- * not be group- or world-writable. Returns a symlink-free absolute path.
- */
-function resolveRealPath(lexical: string, sanctionedRoots: string[]): string {
-  const hopTargets: string[] = [];
-  let current: string = sep;
-  for (const piece of resolve(lexical).split(sep).filter(Boolean)) {
-    current = resolve(current, piece);
-    for (let hops = 0; lstatSync(current).isSymbolicLink(); ) {
-      if (++hops > MAX_SYMLINK_HOPS) {
-        throw new Error(`symlink chain exceeds ${MAX_SYMLINK_HOPS} hops: ${lexical}`);
-      }
-      const linkTarget = readlinkSync(current);
-      const absolute = resolve(dirname(current), linkTarget);
-      if (!sanctionedRoots.some((root) => containedUnder(root, absolute))) {
-        throw new Error(
-          `symlink target escapes managed roots [${sanctionedRoots.join(', ')}]: ${absolute}`,
-        );
-      }
-      hopTargets.push(absolute);
-      current = absolute;
-    }
-  }
-  const uid = typeof process.getuid === 'function' ? process.getuid() : 0;
-  for (const hop of hopTargets) {
-    const stat = statSync(hop);
-    if (stat.uid !== uid && stat.uid !== 0) {
-      throw new Error(`symlink target is not owned by the current user: ${hop}`);
-    }
-    if (stat.mode & 0o022) {
-      throw new Error(`symlink target is group- or world-writable: ${hop}`);
-    }
-  }
-  return current;
-}
-
-function openFileBeneathRoot(
-  root: string,
-  target: string,
-  symlinkTargetRoots: string[] = [],
-): { fd: number; descriptors: number[] } {
+function openFileBeneathRoot(root: string, target: string): { fd: number; descriptors: number[] } {
   const canonicalRoot = resolve(root);
   const canonicalTarget = resolve(target);
   assertCanonicalContainment(canonicalRoot, canonicalTarget);
@@ -157,52 +96,39 @@ function openFileBeneathRoot(
   const fileName = components.pop();
   if (fileName === undefined) throw new Error('managed file path names the managed root');
 
-  // stack#1380: resolve-then-validate. The lexical path must name the managed
-  // root (above); symlink components are then resolved hop-by-hop under the
-  // sanctioned roots (validated per hop), and the descriptor traversal walks
-  // the symlink-free real path — keeping the O_NOFOLLOW chain as the race
-  // guard for anything substituted after resolution.
-  let realRoot: string;
-  try {
-    realRoot = resolveRealPath(canonicalRoot, [canonicalRoot]);
-  } catch (error) {
-    throw secureFilesystemError(
-      'secure descriptor traversal failed: symbolic link, unavailable, or not a directory',
-      error,
-    );
-  }
-  const sanctioned = [realRoot, ...symlinkTargetRoots.map((extra) => resolve(extra))];
-  let realTarget: string;
-  try {
-    realTarget = resolveRealPath(canonicalTarget, sanctioned);
-  } catch (error) {
-    if (error instanceof Error && !('code' in error)) throw error;
-    throw secureFilesystemError(
-      'secure descriptor traversal failed: symbolic link, unavailable, or not a directory',
-      error,
-    );
-  }
-  if (!sanctioned.some((sr) => containedUnder(sr, realTarget) || resolve(sr) === realTarget)) {
-    throw new Error(
-      `resolved path escapes managed roots [${sanctioned.join(', ')}]: ${realTarget}`,
-    );
-  }
-
-  const chain = openDirectoryChain(dirname(realTarget));
+  const rootChain = openDirectoryChain(canonicalRoot);
   try {
+    let parentFd = rootChain.fd;
+    for (const component of components) {
+      try {
+        parentFd = openSync(
+          procDescriptorPath(parentFd, component),
+          constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW,
+        );
+      } catch (error) {
+        throw secureFilesystemError(
+          'path ancestor is a symbolic link, unavailable, or not a directory',
+          error,
+        );
+      }
+      rootChain.descriptors.push(parentFd);
+      if (!fstatSync(parentFd).isDirectory()) {
+        throw new Error('path ancestor is a symbolic link or not a directory');
+      }
+    }
     let fd: number;
     try {
       fd = openSync(
-        procDescriptorPath(chain.fd, basename(realTarget)),
+        procDescriptorPath(parentFd, fileName),
         constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW,
       );
     } catch (error) {
       throw secureFilesystemError('file is a symbolic link or unavailable', error);
     }
-    chain.descriptors.push(fd);
-    return { fd, descriptors: chain.descriptors };
+    rootChain.descriptors.push(fd);
+    return { fd, descriptors: rootChain.descriptors };
   } catch (error) {
-    closeDescriptors(chain.descriptors);
+    closeDescriptors(rootChain.descriptors);
     if (error instanceof Error) throw error;
     throw new Error('secure managed file open failed');
   }
@@ -277,7 +203,7 @@ export function readRegularFileSecure(
   path: string,
   options: SecureFileReadOptions,
 ): SecureFileSnapshot {
-  const openedFile = openFileBeneathRoot(options.root, path, options.symlinkTargetRoots ?? []);
+  const openedFile = openFileBeneathRoot(options.root, path);
   try {
     const opened = fstatSync(openedFile.fd);
     if (!opened.isFile()) throw new Error('managed file is not a regular file');

packages/mosaic/src/runtime/update-checker.reseed.spec.ts

@@ -168,9 +168,7 @@ describe('repairFleetCommsTools', () => {
     const result = repairFleetCommsTools(framework, home);
 
     expect(result).toMatchObject({ ok: false, changed: false });
-    // stack#1380: resolve-then-validate — an escaping symlink is still
-    // refused, with the new escape diagnostic.
-    expect(result.reason).toContain('symlink target escapes managed roots');
+    expect(result.reason).toContain('symbolic link');
     expect(readFileSync(target, 'utf8')).toBe('do not touch\n');
     expect(lstatSync(join(home, 'tools', 'tmux', 'agent-send.sh')).isSymbolicLink()).toBe(true);
   });
@@ -224,10 +222,7 @@ describe('repairFleetCommsTools', () => {
       const result = repairFleetCommsTools(framework, targetHome);
 
       expect(result, testCase.name).toMatchObject({ ok: false, changed: false });
-      // stack#1380: escaping ancestor symlinks stay refused. The home case is
-      // caught by the managed-root guard ('is a symbolic link'); deeper
-      // components by resolve-then-validate ('symlink target escapes').
-      expect(result.reason, testCase.name).toMatch(/symbolic link|symlink target escapes/);
+      expect(result.reason, testCase.name).toContain('symbolic link');
       expect(readdirSync(external), testCase.name).toEqual([]);
     }
   });