perf(test): cut inner-loop fixed overhead to sub-second on cache-fresh runs

- skill-sync check conditioned on content hash of its inputs (skips ~0.3s spawn)
- ensure-test-artifacts: git-blob content-hash staleness; branch switches no longer trigger spurious ~2.6s tsc rebuilds (mtime fallback when dirty)
- isolation guard: cheap --before-fast reusing prior post-run baseline (~2.1s -> ~0.07s); detection proven preserved via injected-leak failure test
- vitest-setup: CI skips 4040-4045 discovery probe unless FUSION_RESERVED_PORTS set; kill-guard wrapper untouched, asymmetry pinned by port-probe-policy tests
- cache-fresh fast path skips sync/artifacts/HOME-prune entirely (mode line: fast-path=cache-fresh)

packages/core/src/__test-utils__/port-probe-policy.ts

@@ -0,0 +1,47 @@
+/**
+ * Pure policy for the reserved-port discovery probe (U3).
+ *
+ * Extracted from vitest-setup.ts so it can be unit-tested with stubbed env,
+ * without importing the setup file (which has top-level await + global side
+ * effects and would run a real port probe on import).
+ *
+ * IMPORTANT: this conditions only the *discovery* probe — the kill-guard
+ * wrapper in vitest-setup.ts always keeps 4040 and any explicitly-declared
+ * ports in its block-set. Skipping discovery in CI never weakens the guard;
+ * there is simply no live dashboard to discover there.
+ */
+
+export function parsePortList(value: string | undefined): number[] {
+  if (!value) return [];
+  return value
+    .split(",")
+    .map((part) => Number.parseInt(part.trim(), 10))
+    .filter((port) => Number.isInteger(port) && port > 0 && port < 65_536);
+}
+
+/**
+ * Whether the per-worker 4040–4045 fetch probe should run.
+ *
+ *  - FUSION_TEST_SKIP_PORT_PROBE=1 always skips (existing escape hatch).
+ *  - In CI (CI=true) the probe is skipped UNLESS FUSION_RESERVED_PORTS is set,
+ *    which signals an intentional live service worth guarding even there.
+ *  - Locally the probe always runs (unchanged behavior).
+ */
+export function shouldRunPortProbe(env: NodeJS.ProcessEnv): boolean {
+  if (env.FUSION_TEST_SKIP_PORT_PROBE === "1") return false;
+  const hasExplicitReservedPorts = parsePortList(env.FUSION_RESERVED_PORTS).length > 0;
+  if (env.CI === "true" && !hasExplicitReservedPorts) return false;
+  return true;
+}
+
+/**
+ * The static reserved-port set derived from env only (no I/O). 4040 is always
+ * included; FUSION_RESERVED_PORTS / PORT / FUSION_SERVER_PORT add more.
+ */
+export function resolveReservedPortsFromEnv(env: NodeJS.ProcessEnv): Set<number> {
+  const reserved = new Set<number>([4040]);
+  for (const port of parsePortList(env.FUSION_RESERVED_PORTS)) reserved.add(port);
+  for (const port of parsePortList(env.PORT)) reserved.add(port);
+  for (const port of parsePortList(env.FUSION_SERVER_PORT)) reserved.add(port);
+  return reserved;
+}

packages/core/src/__test-utils__/vitest-setup.ts

@@ -19,6 +19,10 @@ import { dirname, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { isMainThread } from "node:worker_threads";
 import { assertOutsideRealFusionPath } from "../test-safety.js";
+import {
+  resolveReservedPortsFromEnv,
+  shouldRunPortProbe,
+} from "./port-probe-policy.js";
 
 type FsModule = typeof import("node:fs");
 type FsPromisesModule = typeof import("node:fs/promises");
@@ -475,13 +479,9 @@ function shouldBlockRealTestCli(commandLine: string): boolean {
 //   - any ports listed in FUSION_RESERVED_PORTS (comma-separated escape hatch)
 //   - any port detected by a synchronous probe of localhost candidates
 // Detection runs once per worker at setup time so the regex set is stable.
-function parsePortList(value: string | undefined): number[] {
-  if (!value) return [];
-  return value
-    .split(",")
-    .map((part) => Number.parseInt(part.trim(), 10))
-    .filter((port) => Number.isInteger(port) && port > 0 && port < 65_536);
-}
+// parsePortList / shouldRunPortProbe / resolveReservedPortsFromEnv live in
+// ./port-probe-policy.ts so they can be unit-tested without importing this
+// side-effectful setup module.
 
 async function probeFusionHealthPort(port: number, timeoutMs: number): Promise<boolean> {
   try {
@@ -504,12 +504,15 @@ async function detectLiveFusionPorts(candidates: readonly number[]): Promise<num
   return results.filter((port): port is number => port !== null);
 }
 
+// U3: the per-worker 4040–4045 discovery probe exists to detect a *live local*
+// dashboard so tests can't kill it. In CI there is never a live dashboard, so
+// shouldRunPortProbe() (in ./port-probe-policy.ts) skips the six
+// fetch-with-250ms-timeout calls per worker. This conditions only *discovery*;
+// the reserved-port block wrapper (RESERVED_PORT_KILL_PATTERNS) is untouched and
+// the default plus any declared ports remain in the guard set regardless.
 async function resolveReservedFusionPorts(): Promise<number[]> {
-  const reserved = new Set<number>([4040]);
-  for (const port of parsePortList(process.env.FUSION_RESERVED_PORTS)) reserved.add(port);
-  for (const port of parsePortList(process.env.PORT)) reserved.add(port);
-  for (const port of parsePortList(process.env.FUSION_SERVER_PORT)) reserved.add(port);
-  if (process.env.FUSION_TEST_SKIP_PORT_PROBE !== "1") {
+  const reserved = resolveReservedPortsFromEnv(process.env);
+  if (shouldRunPortProbe(process.env)) {
     const probeRange = [4040, 4041, 4042, 4043, 4044, 4045];
     for (const port of await detectLiveFusionPorts(probeRange)) reserved.add(port);
   }

packages/core/src/__tests__/port-probe-policy.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect } from "vitest";
+import {
+  parsePortList,
+  resolveReservedPortsFromEnv,
+  shouldRunPortProbe,
+} from "../__test-utils__/port-probe-policy.js";
+
+// U3 / R10: the discovery probe is conditioned by env, but the reserved-port
+// guard SET must never lose 4040 or any explicitly-declared port. These tests
+// pin that asymmetry without spinning up a real vitest worker or live server.
+
+describe("shouldRunPortProbe", () => {
+  it("skips the probe in CI when no reserved ports are declared (zero fetches)", () => {
+    expect(shouldRunPortProbe({ CI: "true" })).toBe(false);
+  });
+
+  it("runs the probe locally (no CI flag)", () => {
+    expect(shouldRunPortProbe({})).toBe(true);
+  });
+
+  it("still runs the probe in CI when FUSION_RESERVED_PORTS is explicitly set", () => {
+    expect(shouldRunPortProbe({ CI: "true", FUSION_RESERVED_PORTS: "4040,5000" })).toBe(true);
+  });
+
+  it("honors the FUSION_TEST_SKIP_PORT_PROBE=1 escape hatch everywhere", () => {
+    expect(shouldRunPortProbe({ FUSION_TEST_SKIP_PORT_PROBE: "1" })).toBe(false);
+    expect(
+      shouldRunPortProbe({ FUSION_TEST_SKIP_PORT_PROBE: "1", FUSION_RESERVED_PORTS: "5000" }),
+    ).toBe(false);
+  });
+});
+
+describe("resolveReservedPortsFromEnv", () => {
+  it("always includes 4040 even with an empty env (guard never drops the default)", () => {
+    expect(resolveReservedPortsFromEnv({}).has(4040)).toBe(true);
+  });
+
+  it("includes explicitly-declared reserved ports in CI (guard set asymmetry)", () => {
+    const reserved = resolveReservedPortsFromEnv({ CI: "true", FUSION_RESERVED_PORTS: "5000,6000" });
+    expect(reserved.has(4040)).toBe(true);
+    expect(reserved.has(5000)).toBe(true);
+    expect(reserved.has(6000)).toBe(true);
+  });
+
+  it("folds in PORT and FUSION_SERVER_PORT", () => {
+    const reserved = resolveReservedPortsFromEnv({ PORT: "8080", FUSION_SERVER_PORT: "9090" });
+    expect(reserved.has(8080)).toBe(true);
+    expect(reserved.has(9090)).toBe(true);
+  });
+});
+
+describe("parsePortList", () => {
+  it("ignores invalid and out-of-range entries", () => {
+    expect(parsePortList("4040, abc, 70000, -1, 5000")).toEqual([4040, 5000]);
+  });
+
+  it("returns an empty list for undefined", () => {
+    expect(parsePortList(undefined)).toEqual([]);
+  });
+});

scripts/__tests__/check-test-isolation.test.mjs

@@ -111,6 +111,56 @@ test("fails when protected .fusion existence changes after baseline", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// U3: --before-fast (cheap single-probe baseline). Detection must be preserved.
+// ---------------------------------------------------------------------------
+
+test("--before-fast still detects an injected temp leak (guard strength preserved)", () => {
+  withFixture(({ cwd, home }) => {
+    // Prime a full baseline so --before-fast has a prior unstable classification.
+    assert.equal(runScript(["--before"], { cwd, home }).status, 0);
+    // Fast before-pass (reuses prior classification, skips the 2s probe).
+    const fast = runScript(["--before-fast"], { cwd, home });
+    assert.equal(fast.status, 0);
+    assert.match(fast.stdout, /Baseline recorded \(fast\)/);
+
+    // Inject a leak after the fast baseline.
+    const leak = path.join(tmpdir(), `fusion-test-leak-fast-${process.pid}`);
+    mkdirSync(leak, { recursive: true });
+    try {
+      const after = runScript([], { cwd, home });
+      assert.equal(after.status, 1, after.stdout);
+      assert.match(after.stderr, /leaked temp director/i);
+    } finally {
+      rmSync(leak, { recursive: true, force: true });
+    }
+  });
+});
+
+test("--before-fast still detects a protected .fusion mutation after baseline", () => {
+  withFixture(({ cwd, home }) => {
+    assert.equal(runScript(["--before"], { cwd, home }).status, 0);
+    assert.equal(runScript(["--before-fast"], { cwd, home }).status, 0);
+    writeFileSync(path.join(cwd, ".fusion", "fast-mutated.txt"), "x");
+    const after = runScript([], { cwd, home });
+    assert.equal(after.status, 1);
+    assert.match(after.stderr, /protected live \.fusion data changed/i);
+  });
+});
+
+test("--before-fast falls back to the full probe when no prior baseline exists", () => {
+  withFixture(({ cwd, home }) => {
+    // No --before has run for this cwd-namespaced baseline; --before-fast must
+    // still produce a usable baseline (full path) and the after-check passes.
+    const fast = runScript(["--before-fast"], { cwd, home });
+    assert.equal(fast.status, 0);
+    // Full fallback prints the non-fast baseline message.
+    assert.match(fast.stdout, /Baseline recorded:/);
+    const after = runScript([], { cwd, home });
+    assert.equal(after.status, 0);
+  });
+});
+
 test("passes when HOME .fusion is externally active during baseline and check", () => {
   withFixture(({ cwd, home }) => {
     const churnScript = `

scripts/__tests__/content-hash.test.mjs

@@ -0,0 +1,153 @@
+/**
+ * Unit tests for scripts/lib/content-hash.mjs (U3).
+ *
+ * Runner: node --test scripts/__tests__/content-hash.test.mjs
+ *
+ * These tests use injectable gitFn/readFn stubs so they never touch the real
+ * repo or shell out to git.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { computeContentHash } from "../lib/content-hash.mjs";
+
+/**
+ * Build a fake git runner from a description of the tree.
+ *
+ * @param {object} tree
+ * @param {Record<string,string>} tree.tracked   path -> blob sha (clean tracked files)
+ * @param {string[]} [tree.dirty]                tracked paths that are modified in worktree
+ * @param {string[]} [tree.untracked]            untracked-not-ignored paths
+ */
+function fakeGit(tree) {
+  const { tracked = {}, dirty = [], untracked = [] } = tree;
+  return (args) => {
+    if (args[0] === "ls-files") {
+      return Object.entries(tracked)
+        .map(([file, sha]) => `100644 ${sha} 0\t${file}`)
+        .join("\n");
+    }
+    if (args[0] === "status") {
+      const lines = [];
+      for (const file of dirty) lines.push(` M ${file}`);
+      for (const file of untracked) lines.push(`?? ${file}`);
+      return lines.join("\n");
+    }
+    return null;
+  };
+}
+
+const readBytes = (contentByPath) => (absPath) => {
+  // absPath is rootDir + "/" + relPath; match on suffix.
+  for (const [rel, content] of Object.entries(contentByPath)) {
+    if (absPath.endsWith(rel)) return Buffer.from(content);
+  }
+  throw Object.assign(new Error("ENOENT"), { code: "ENOENT" });
+};
+
+const base = { rootDir: "/repo", inputPaths: ["packages/core/src"] };
+
+test("computeContentHash is stable for identical tracked content", () => {
+  const git = fakeGit({ tracked: { "packages/core/src/a.ts": "aaa", "packages/core/src/b.ts": "bbb" } });
+  const h1 = computeContentHash({ ...base, gitFn: git, readFn: readBytes({}) });
+  const h2 = computeContentHash({ ...base, gitFn: git, readFn: readBytes({}) });
+  assert.equal(h1, h2);
+  assert.equal(h1.length, 64);
+});
+
+test("computeContentHash busts when a tracked blob sha changes (real source change)", () => {
+  const before = computeContentHash({
+    ...base,
+    gitFn: fakeGit({ tracked: { "packages/core/src/a.ts": "aaa" } }),
+    readFn: readBytes({}),
+  });
+  const after = computeContentHash({
+    ...base,
+    gitFn: fakeGit({ tracked: { "packages/core/src/a.ts": "zzz" } }),
+    readFn: readBytes({}),
+  });
+  assert.notEqual(before, after);
+});
+
+test("branch-switch with identical content yields the same hash (mtime-independent)", () => {
+  // Two 'branches' with the same tracked blob shas → identical hash, even though
+  // a real checkout would rewrite mtimes. The hash never reads mtime.
+  const git = fakeGit({ tracked: { "packages/core/src/a.ts": "aaa" } });
+  const branchA = computeContentHash({ ...base, gitFn: git, readFn: readBytes({}) });
+  const branchB = computeContentHash({ ...base, gitFn: git, readFn: readBytes({}) });
+  assert.equal(branchA, branchB);
+});
+
+test("dirty tracked file is hashed by working-tree bytes, not the stale index sha", () => {
+  // Same index blob sha, but the worktree content differs → different hashes.
+  const clean = computeContentHash({
+    ...base,
+    gitFn: fakeGit({ tracked: { "packages/core/src/a.ts": "aaa" } }),
+    readFn: readBytes({ "packages/core/src/a.ts": "ON-DISK-V1" }),
+  });
+  const dirty = computeContentHash({
+    ...base,
+    gitFn: fakeGit({ tracked: { "packages/core/src/a.ts": "aaa" }, dirty: ["packages/core/src/a.ts"] }),
+    readFn: readBytes({ "packages/core/src/a.ts": "ON-DISK-V2" }),
+  });
+  assert.notEqual(clean, dirty);
+});
+
+test("two different working-tree contents of a dirty file produce different hashes", () => {
+  const v1 = computeContentHash({
+    ...base,
+    gitFn: fakeGit({ tracked: { "packages/core/src/a.ts": "aaa" }, dirty: ["packages/core/src/a.ts"] }),
+    readFn: readBytes({ "packages/core/src/a.ts": "V1" }),
+  });
+  const v2 = computeContentHash({
+    ...base,
+    gitFn: fakeGit({ tracked: { "packages/core/src/a.ts": "aaa" }, dirty: ["packages/core/src/a.ts"] }),
+    readFn: readBytes({ "packages/core/src/a.ts": "V2" }),
+  });
+  assert.notEqual(v1, v2);
+});
+
+test("untracked file is folded into the hash via its bytes", () => {
+  const without = computeContentHash({
+    ...base,
+    gitFn: fakeGit({ tracked: { "packages/core/src/a.ts": "aaa" } }),
+    readFn: readBytes({}),
+  });
+  const withUntracked = computeContentHash({
+    ...base,
+    gitFn: fakeGit({ tracked: { "packages/core/src/a.ts": "aaa" }, untracked: ["packages/core/src/new.ts"] }),
+    readFn: readBytes({ "packages/core/src/new.ts": "brand new" }),
+  });
+  assert.notEqual(without, withUntracked);
+});
+
+test("porcelain status parsing tolerates spacing variants (M  path vs ' M path')", () => {
+  // git emits the worktree-modified code in either " M path" or "M  path" form
+  // depending on staged/worktree state; both must be recognized as dirty.
+  const tracked = { "packages/core/src/a.ts": "aaa" };
+  const readFn = (absPath) => (absPath.endsWith("a.ts") ? Buffer.from("ON-DISK") : Buffer.from(""));
+
+  const variantGit = (statusLine) => (args) => {
+    if (args[0] === "ls-files") {
+      return Object.entries(tracked).map(([f, s]) => `100644 ${s} 0\t${f}`).join("\n");
+    }
+    if (args[0] === "status") return statusLine;
+    return null;
+  };
+
+  const clean = computeContentHash({ ...base, gitFn: variantGit(""), readFn: () => Buffer.from("") });
+  const variantA = computeContentHash({ ...base, gitFn: variantGit(" M packages/core/src/a.ts"), readFn });
+  const variantB = computeContentHash({ ...base, gitFn: variantGit("M  packages/core/src/a.ts"), readFn });
+
+  assert.notEqual(clean, variantA, "leading-space variant must register as dirty");
+  assert.notEqual(clean, variantB, "trailing-space variant must register as dirty");
+  // Both variants describe the same dirty file/content → identical hash.
+  assert.equal(variantA, variantB);
+});
+
+test("versionPrefix busts the hash so a format bump invalidates all entries", () => {
+  const git = fakeGit({ tracked: { "packages/core/src/a.ts": "aaa" } });
+  const v1 = computeContentHash({ ...base, versionPrefix: "v1", gitFn: git, readFn: readBytes({}) });
+  const v2 = computeContentHash({ ...base, versionPrefix: "v2", gitFn: git, readFn: readBytes({}) });
+  assert.notEqual(v1, v2);
+});

scripts/__tests__/ensure-test-artifacts.test.mjs

@@ -7,9 +7,25 @@ import {
   detectMissingArtifacts,
   detectMissingOrStaleArtifacts,
   ensureTestArtifacts,
+  isStale,
   REQUIRED_BUILD_PACKAGES,
 } from "../ensure-test-artifacts.mjs";
 
+const ENGINE_ENTRY = REQUIRED_BUILD_PACKAGES.find((pkg) => pkg.name === "@fusion/engine");
+
+/**
+ * A git stub that returns a fixed blob sha for engine src, and reports it as a
+ * git work tree. Lets us drive the content-hash cache deterministically.
+ */
+function fakeGitForEngine(blobSha) {
+  return (args) => {
+    if (args[0] === "rev-parse") return "true";
+    if (args[0] === "ls-files") return `100644 ${blobSha} 0\tpackages/engine/src/index.ts`;
+    if (args[0] === "status") return ""; // clean
+    return null;
+  };
+}
+
 test("detectMissingArtifacts returns missing package list", () => {
   const missing = detectMissingArtifacts("/repo", () => false);
   assert.equal(missing.length, REQUIRED_BUILD_PACKAGES.length);
@@ -417,3 +433,80 @@ test("ensureTestArtifacts remediation labels missing artifact paths", () => {
   assert.equal(exitCode, 3);
   assert.match(stderr, /\[test-bootstrap\] missing: plugins\/fusion-plugin-dependency-graph\/dist\/dashboard-view.js/);
 });
+
+// ---------------------------------------------------------------------------
+// U3: content-hash artifact cache — branch-switch no-rebuild + real-change
+// rebuild + dirty-file mtime fallback.
+// ---------------------------------------------------------------------------
+
+// An fs where engine src mtime (3000) is newer than dist (1000): the mtime path
+// would flag engine as stale. The content-hash cache should override that when
+// the source hash is unchanged since the last build.
+function engineStaleByMtimeFs() {
+  return createStaleFsForPackage(
+    { sourceDir: "/repo/packages/engine/src", artifactPathFragment: "packages/engine/dist/" },
+    { artifactMtime: 1000, sourceMtime: 3000 },
+  );
+}
+
+test("isStale: content-hash cache hit skips rebuild even when mtimes say stale (branch-switch)", () => {
+  const { statFn, readdirFn } = engineStaleByMtimeFs();
+  const git = fakeGitForEngine("blobA");
+  // Cache records the exact source hash for the current (blobA) clean content,
+  // so isStale's content-hash short-circuit must report not-stale.
+  const matchingHash = sourceHashFor(git);
+  const artifactCache = { version: 1, entries: { "@fusion/engine": { sourceHash: matchingHash } } };
+
+  const stale = isStale(ENGINE_ENTRY, "/repo", statFn, readdirFn, () => true, { artifactCache, gitFn: git });
+  assert.equal(stale, false, "cache hit on unchanged content must not be stale");
+});
+
+test("isStale: real source change (different blob sha) rebuilds despite cached hash", () => {
+  const { statFn, readdirFn } = engineStaleByMtimeFs();
+  const oldHash = sourceHashFor(fakeGitForEngine("blobOLD"));
+  const artifactCache = { version: 1, entries: { "@fusion/engine": { sourceHash: oldHash } } };
+
+  // Current content is blobNEW → hash differs from cache → fall through to mtime,
+  // which reports stale (src 3000 > dist 1000).
+  const git = fakeGitForEngine("blobNEW");
+  const stale = isStale(ENGINE_ENTRY, "/repo", statFn, readdirFn, () => true, { artifactCache, gitFn: git });
+  assert.equal(stale, true, "changed source content must rebuild");
+});
+
+test("isStale: dirty/untracked git work tree falls back to mtime (no false cache hit)", () => {
+  const { statFn, readdirFn } = engineStaleByMtimeFs();
+  // git stub reports the file as DIRTY: status returns a modification line, so
+  // the content hash reflects working-tree bytes. With a cache keyed to the
+  // clean blob, the hash won't match → mtime fallback → stale.
+  const cleanHash = sourceHashFor(fakeGitForEngine("blobA"));
+  const artifactCache = { version: 1, entries: { "@fusion/engine": { sourceHash: cleanHash } } };
+
+  const dirtyGit = (args) => {
+    if (args[0] === "rev-parse") return "true";
+    if (args[0] === "ls-files") return `100644 blobA 0\tpackages/engine/src/index.ts`;
+    if (args[0] === "status") return ` M packages/engine/src/index.ts`;
+    return null;
+  };
+  const stale = isStale(ENGINE_ENTRY, "/repo", statFn, readdirFn, () => true, { artifactCache, gitFn: dirtyGit });
+  assert.equal(stale, true, "dirty working tree must not produce a false cache hit");
+});
+
+test("isStale: not a git work tree falls back to mtime", () => {
+  const { statFn, readdirFn } = engineStaleByMtimeFs();
+  const noGit = (args) => (args[0] === "rev-parse" ? "false" : null);
+  const artifactCache = { version: 1, entries: { "@fusion/engine": { sourceHash: "whatever" } } };
+  const stale = isStale(ENGINE_ENTRY, "/repo", statFn, readdirFn, () => true, { artifactCache, gitFn: noGit });
+  assert.equal(stale, true, "no git → mtime fallback → stale");
+});
+
+// Helper: compute the engine source hash the production code would for a given
+// git stub, by re-importing computeContentHash with the same inputs/version.
+import { computeContentHash as _computeContentHash } from "../lib/content-hash.mjs";
+function sourceHashFor(gitFn) {
+  return _computeContentHash({
+    rootDir: "/repo",
+    inputPaths: ENGINE_ENTRY.staleAgainstGlobs.map((g) => g.sourcePath),
+    versionPrefix: "artifact-v1",
+    gitFn,
+  });
+}

scripts/__tests__/skill-sync-cache.test.mjs

@@ -0,0 +1,112 @@
+/**
+ * Unit tests for the U3 skill-sync skip cache in scripts/sync-fusion-skill-tools.mjs.
+ *
+ * Runner: node --test scripts/__tests__/skill-sync-cache.test.mjs
+ *
+ * Uses an isolated temp rootDir with a fabricated node_modules/.cache/fusion so
+ * the real cache is never touched.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import {
+  SKILL_SYNC_INPUT_PATHS,
+  computeSkillSyncHash,
+  isSkillSyncCheckCached,
+  recordSkillSyncCheckPass,
+} from "../sync-fusion-skill-tools.mjs";
+
+function withRoot(fn) {
+  const root = mkdtempSync(path.join(tmpdir(), "skill-sync-cache-"));
+  try {
+    fn(root);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+}
+
+/**
+ * A git stub that reports each input path as a tracked file with a stable blob
+ * sha derived from a content map, and reports clean status. `contents` maps a
+ * repo-relative path to a sha string.
+ */
+function fakeGit(shaByPath, { dirty = [] } = {}) {
+  return (args) => {
+    if (args[0] === "ls-files") {
+      return SKILL_SYNC_INPUT_PATHS.map((p) => `100644 ${shaByPath[p] ?? "0000"} 0\t${p}`).join("\n");
+    }
+    if (args[0] === "status") {
+      return dirty.map((p) => ` M ${p}`).join("\n");
+    }
+    return null;
+  };
+}
+
+const baseShas = Object.fromEntries(SKILL_SYNC_INPUT_PATHS.map((p, i) => [p, `sha${i}`]));
+
+test("recordSkillSyncCheckPass then isSkillSyncCheckCached returns true on unchanged inputs", () => {
+  withRoot((root) => {
+    const deps = { gitFn: fakeGit(baseShas), readFn: () => Buffer.from("") };
+    assert.equal(isSkillSyncCheckCached(root, deps), false, "no cache yet");
+    recordSkillSyncCheckPass(root, deps);
+    assert.equal(isSkillSyncCheckCached(root, deps), true, "cache hit after recording");
+  });
+});
+
+test("isSkillSyncCheckCached returns false after an input blob sha changes", () => {
+  withRoot((root) => {
+    const deps = { gitFn: fakeGit(baseShas), readFn: () => Buffer.from("") };
+    recordSkillSyncCheckPass(root, deps);
+    assert.equal(isSkillSyncCheckCached(root, deps), true);
+
+    // Change one input's blob sha (a skill tool / extension edit landed).
+    const changed = { ...baseShas, [SKILL_SYNC_INPUT_PATHS[0]]: "DIFFERENT" };
+    const changedDeps = { gitFn: fakeGit(changed), readFn: () => Buffer.from("") };
+    assert.equal(isSkillSyncCheckCached(root, changedDeps), false, "changed input must bust cache");
+  });
+});
+
+test("isSkillSyncCheckCached returns false on a stale cache-format version", () => {
+  withRoot((root) => {
+    const cacheDir = path.join(root, "node_modules", ".cache", "fusion");
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(
+      path.join(cacheDir, "skill-sync-cache.json"),
+      JSON.stringify({ version: 999, hash: "x" }),
+    );
+    const deps = { gitFn: fakeGit(baseShas), readFn: () => Buffer.from("") };
+    assert.equal(isSkillSyncCheckCached(root, deps), false);
+  });
+});
+
+test("computeSkillSyncHash is stable for identical inputs and busts when dirty content changes", () => {
+  withRoot((root) => {
+    const clean = computeSkillSyncHash(root, { gitFn: fakeGit(baseShas), readFn: () => Buffer.from("X") });
+    const same = computeSkillSyncHash(root, { gitFn: fakeGit(baseShas), readFn: () => Buffer.from("X") });
+    assert.equal(clean, same);
+
+    // Same blob shas but a dirty worktree edit on one file → hash differs.
+    const dirtyDeps = {
+      gitFn: fakeGit(baseShas, { dirty: [SKILL_SYNC_INPUT_PATHS[0]] }),
+      readFn: () => Buffer.from("EDITED"),
+    };
+    assert.notEqual(clean, computeSkillSyncHash(root, dirtyDeps));
+  });
+});
+
+test("recordSkillSyncCheckPass writes a versioned payload with a passedAt timestamp", () => {
+  withRoot((root) => {
+    const deps = { gitFn: fakeGit(baseShas), readFn: () => Buffer.from("") };
+    recordSkillSyncCheckPass(root, deps);
+    const raw = JSON.parse(
+      readFileSync(path.join(root, "node_modules", ".cache", "fusion", "skill-sync-cache.json"), "utf8"),
+    );
+    assert.equal(raw.version, 1);
+    assert.equal(typeof raw.hash, "string");
+    assert.equal(raw.hash.length, 64);
+    assert.ok(!Number.isNaN(Date.parse(raw.passedAt)));
+  });
+});

scripts/__tests__/test-changed.test.mjs

@@ -28,6 +28,7 @@ import {
   knownIsolatedHomeBasenames,
   __setCleanupRmSyncForTests,
   emitModeDecision,
+  pruneFusionTestHomes,
 } from "../test-changed.mjs";
 
 import { mkdirSync, writeFileSync, mkdtempSync, rmSync, existsSync } from "node:fs";
@@ -857,3 +858,77 @@ test("emitModeDecision: distinct full reasons round-trip from decideExecutionPla
   const forced = decideExecutionPlan({ forceFullSuite: true });
   assert.equal(emitModeDecision(forced, () => {}), "[test-changed] mode=full reason=forced packages=0");
 });
+
+// ---------------------------------------------------------------------------
+// U3: cache-fresh fast path — when every changed package is cache-fresh,
+// applyCacheToPlan yields zero active packages, which is the signal that lets
+// main() skip the skill-sync spawn, artifact-ensure, HOME creation, and prune.
+// ---------------------------------------------------------------------------
+
+test("applyCacheToPlan: all packages cache-fresh → activePackages empty (fast-path trigger)", () => {
+  const sha = "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef";
+  const gitFn = fakeGit(sha);
+  const packageDirByName = dirByName([["@fusion/core", "packages/core"]]);
+  const hash = hashWithFakeGit("packages/core", sha);
+
+  const cache = {
+    version: 1,
+    entries: { "@fusion/core": { hash, passedAt: new Date().toISOString(), command: "test" } },
+  };
+
+  const { cachedPackages, activePackages } = applyCacheToPlan(
+    { mode: "changed", packages: ["@fusion/core"] },
+    { gitFn, packageDirByName, readCacheFn: () => cache },
+  );
+
+  assert.deepEqual(activePackages, []);
+  assert.deepEqual(cachedPackages, ["@fusion/core"]);
+});
+
+test("applyCacheToPlan: a changed (non-cached) package keeps the run active (no false fast path)", () => {
+  const gitFn = fakeGit("1111111111111111111111111111111111111111");
+  const packageDirByName = dirByName([["@fusion/core", "packages/core"]]);
+  const staleCache = {
+    version: 1,
+    entries: { "@fusion/core": { hash: "OLDHASH", passedAt: new Date().toISOString(), command: "test" } },
+  };
+
+  const { activePackages } = applyCacheToPlan(
+    { mode: "changed", packages: ["@fusion/core"] },
+    { gitFn, packageDirByName, readCacheFn: () => staleCache },
+  );
+
+  assert.deepEqual(activePackages, ["@fusion/core"]);
+});
+
+test("pruneFusionTestHomes: bounded — removes at most maxEntries per call", () => {
+  const created = [];
+  try {
+    for (let i = 0; i < 5; i++) {
+      const dir = path.join(tmpdir(), `fusion-test-home-root-prune-budget-${process.pid}-${i}`);
+      mkdirSync(dir, { recursive: true });
+      created.push(dir);
+    }
+    // Cap at 2 → at least 3 of ours survive this call.
+    pruneFusionTestHomes(2);
+    const survivors = created.filter((dir) => existsSync(dir));
+    assert.ok(survivors.length >= 3, `expected >=3 survivors with cap=2, got ${survivors.length}`);
+  } finally {
+    for (const dir of created) rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pruneFusionTestHomes: only targets the fusion-test-home-root- prefix", () => {
+  const ours = path.join(tmpdir(), `fusion-test-home-root-prune-prefix-${process.pid}`);
+  const foreign = path.join(tmpdir(), `not-ours-prune-prefix-${process.pid}`);
+  mkdirSync(ours, { recursive: true });
+  mkdirSync(foreign, { recursive: true });
+  try {
+    pruneFusionTestHomes();
+    assert.equal(existsSync(ours), false, "our prefixed dir should be pruned");
+    assert.equal(existsSync(foreign), true, "foreign dir must be left untouched");
+  } finally {
+    rmSync(ours, { recursive: true, force: true });
+    rmSync(foreign, { recursive: true, force: true });
+  }
+});

scripts/check-test-isolation.mjs

@@ -171,6 +171,50 @@ function sleepMs(ms) {
   spawnSync(process.platform === "win32" ? "powershell" : "sleep", process.platform === "win32" ? ["-NoProfile", "-Command", `Start-Sleep -Milliseconds ${ms}`] : [String(ms / 1000)], { stdio: "ignore" });
 }
 
+function readPreviousBaseline() {
+  if (!existsSync(BASELINE_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync(BASELINE_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// U3: fast baseline. The expensive part of recordBaseline() is the 2s mutability
+// probe (5 snapshots × 500ms) that classifies which protected .fusion dirs are
+// externally-active (a live dashboard). That classification is stable across
+// back-to-back inner-loop runs, so when the previous run already recorded it we
+// reuse it and skip the probe. Detection is NOT weakened: the post-run check
+// still runs its own independent mutability probe on any candidate violation
+// before failing, and engine-lock detection is race-free. If no previous
+// baseline exists (first run, rotated tmp), we fall back to the full probe.
+function recordBaselineFast() {
+  const previous = readPreviousBaseline();
+  if (!previous || !Array.isArray(previous.unstableProtectedDirs)) {
+    recordBaseline();
+    return;
+  }
+
+  const latestProtected = snapshotProtectedFusion();
+  // Re-confirm engine-lock-active dirs cheaply (no sleep) so a dashboard that
+  // started since the previous run is still classified unstable up front.
+  const unstableProtectedDirs = new Set(previous.unstableProtectedDirs);
+  for (const entry of latestProtected) {
+    if (isFusionEngineActive(entry.dir)) unstableProtectedDirs.add(entry.dir);
+  }
+
+  const payload = {
+    tmpNames: snapshotTmp().map((e) => e.name),
+    protectedFusion: latestProtected,
+    unstableProtectedDirs: [...unstableProtectedDirs],
+  };
+  writeFileSync(BASELINE_FILE, JSON.stringify(payload));
+  console.log(`[test-isolation] Baseline recorded (fast): ${payload.tmpNames.length} temp dir(s), ${payload.protectedFusion.length} protected .fusion root(s).`);
+  if (unstableProtectedDirs.size > 0) {
+    console.log(`[test-isolation] Reusing ${unstableProtectedDirs.size} externally-active protected dir(s) from prior run.`);
+  }
+}
+
 function recordBaseline() {
   const samples = [snapshotProtectedFusion()];
   for (let i = 0; i < 4; i++) {
@@ -331,7 +375,9 @@ function checkAgainstBaseline() {
 }
 
 const args = process.argv.slice(2);
-if (args.includes("--before")) {
+if (args.includes("--before-fast")) {
+  recordBaselineFast();
+} else if (args.includes("--before")) {
   recordBaseline();
 } else {
   checkAgainstBaseline();

scripts/ensure-test-artifacts.mjs

@@ -1,8 +1,14 @@
 #!/usr/bin/env node
 
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
+import {
+  computeContentHash,
+  defaultGitRunner,
+  fusionCacheDir,
+  readJsonCache,
+} from "./lib/content-hash.mjs";
 
 export const REQUIRED_BUILD_PACKAGES = [
   { name: "@fusion/core", requiredArtifacts: ["packages/core/dist/index.js"] },
@@ -46,6 +52,83 @@ export const REQUIRED_BUILD_PACKAGES = [
   },
 ];
 
+// ---------------------------------------------------------------------------
+// U3: content-hash artifact cache.
+//
+// The mtime-based staleness check (collectNewestSourceMtimeMs vs the dist
+// artifact mtime) fires spuriously on branch switches: `git checkout` rewrites
+// source-file mtimes to "now" even when content is identical, so dist looks
+// stale and we pay a needless `tsc` rebuild inside the inner-loop budget.
+//
+// The fix: after a successful build, cache a git-blob content hash of the
+// package's source inputs. On the next run, if the current content hash matches
+// the cached one, the dist is up to date regardless of mtimes — skip the
+// rebuild. A real source edit changes the hash and rebuilds.
+//
+// Correctness over speed:
+//   - computeContentHash hashes working-tree bytes for dirty/untracked files,
+//     so an unstaged source edit busts the hash (git's index blob SHA would be
+//     stale). See scripts/lib/content-hash.mjs.
+//   - If git is unavailable, or the cache has no entry yet, we FALL BACK to the
+//     mtime comparison — we never silently skip a needed rebuild.
+// ---------------------------------------------------------------------------
+
+const ARTIFACT_CACHE_VERSION = 1;
+
+function artifactCachePath(rootDir) {
+  return path.join(fusionCacheDir(rootDir), "artifact-cache.json");
+}
+
+function readArtifactCache(rootDir) {
+  const cache = readJsonCache(artifactCachePath(rootDir), null);
+  if (!cache || cache.version !== ARTIFACT_CACHE_VERSION || typeof cache.entries !== "object") {
+    return { version: ARTIFACT_CACHE_VERSION, entries: {} };
+  }
+  return cache;
+}
+
+/**
+ * Compute the source content hash for a package entry, or null when it has no
+ * source globs (missing-only packages don't use the staleness cache) or git is
+ * unavailable so we must fall back to mtime.
+ */
+function computeArtifactSourceHash(pkgEntry, rootDir, gitFn = defaultGitRunner) {
+  if (!pkgEntry?.staleAgainstGlobs?.length) return null;
+  // Probe git availability once; computeContentHash also tolerates null but we
+  // want an explicit "fall back to mtime" signal when not in a git work tree.
+  const probe = gitFn(["rev-parse", "--is-inside-work-tree"], rootDir);
+  if (probe !== "true") return null;
+  const inputPaths = pkgEntry.staleAgainstGlobs.map((glob) => glob.sourcePath);
+  return computeContentHash({
+    rootDir,
+    inputPaths,
+    versionPrefix: `artifact-v${ARTIFACT_CACHE_VERSION}`,
+    gitFn,
+  });
+}
+
+/**
+ * Persist the source content hash for each freshly-built package so the next
+ * run can skip the rebuild when content is unchanged.
+ */
+export function recordArtifactBuild(pkgEntries, rootDir, gitFn = defaultGitRunner) {
+  try {
+    const cache = readArtifactCache(rootDir);
+    let wrote = false;
+    for (const pkgEntry of pkgEntries) {
+      const hash = computeArtifactSourceHash(pkgEntry, rootDir, gitFn);
+      if (hash === null) continue;
+      cache.entries[pkgEntry.name] = { sourceHash: hash, builtAt: new Date().toISOString() };
+      wrote = true;
+    }
+    if (!wrote) return;
+    mkdirSync(fusionCacheDir(rootDir), { recursive: true });
+    writeFileSync(artifactCachePath(rootDir), JSON.stringify(cache, null, 2));
+  } catch {
+    // Cache write is best-effort; a failure just means we mtime-check next time.
+  }
+}
+
 function collectNewestSourceMtimeMs(sourceDir, statFn, readdirFn) {
   let newest = 0;
   const stack = [sourceDir];
@@ -87,9 +170,27 @@ export function isStale(
   statFn = statSync,
   readdirFn = readdirSync,
   existsFn = existsSync,
+  cacheOptions = {},
 ) {
   if (!pkgEntry?.staleAgainstGlobs?.length) return false;
 
+  // U3: content-hash short-circuit. If the package's source content hash matches
+  // the hash captured at the last successful build, dist is up to date even
+  // when mtimes say otherwise (branch-switch churn). Only trust this when the
+  // cache opts in AND a hash is computable (git available, not dirty-fallback).
+  const { artifactCache, gitFn } = cacheOptions;
+  if (artifactCache) {
+    const entry = artifactCache.entries?.[pkgEntry.name];
+    if (entry?.sourceHash) {
+      const currentHash = computeArtifactSourceHash(pkgEntry, rootDir, gitFn);
+      if (currentHash !== null && currentHash === entry.sourceHash) {
+        return false; // Content unchanged since last build — not stale.
+      }
+      // Hash mismatch or unavailable → fall through to the mtime check below,
+      // which never under-reports staleness.
+    }
+  }
+
   let minArtifactMtimeMs = Number.POSITIVE_INFINITY;
   for (const artifactPath of pkgEntry.requiredArtifacts) {
     const fullPath = path.join(rootDir, artifactPath);
@@ -119,11 +220,12 @@ export function detectMissingOrStaleArtifacts(
   existsFn = existsSync,
   statFn = statSync,
   readdirFn = readdirSync,
+  cacheOptions = {},
 ) {
   return REQUIRED_BUILD_PACKAGES.filter((pkg) => {
     const missing = pkg.requiredArtifacts.some((artifactPath) => !existsFn(path.join(rootDir, artifactPath)));
     if (missing) return true;
-    return isStale(pkg, rootDir, statFn, readdirFn, existsFn);
+    return isStale(pkg, rootDir, statFn, readdirFn, existsFn, cacheOptions);
   });
 }
 
@@ -218,7 +320,41 @@ export function ensureTestArtifacts(
   runOptions = {},
 ) {
   const resolvedRootDir = resolveWorkspaceRoot(rootDir);
-  const missingOrStale = detectMissingOrStaleArtifacts(resolvedRootDir, existsFn, statFn, readdirFn);
+
+  // U3: load the content-hash cache so branch-switch mtime churn doesn't force a
+  // rebuild. The default-runner (real CLI) path uses it; injected test runners
+  // can opt in via runOptions.artifactCache / runOptions.gitFn but default to
+  // disabled so existing mtime-based tests keep exercising the mtime path.
+  const useContentCache = runFn === run || runOptions.artifactCache !== undefined;
+  const cacheOptions = useContentCache
+    ? {
+        artifactCache: runOptions.artifactCache ?? readArtifactCache(resolvedRootDir),
+        gitFn: runOptions.gitFn ?? defaultGitRunner,
+      }
+    : {};
+
+  const missingOrStale = detectMissingOrStaleArtifacts(resolvedRootDir, existsFn, statFn, readdirFn, cacheOptions);
+
+  // U3: seed the content-hash cache for packages whose dist is already fresh
+  // (by mtime or a prior build) but have no cache entry yet. This "adopts" the
+  // current source content as the built baseline so the NEXT run — e.g. after a
+  // branch switch rewrites mtimes to "now" without changing content — gets a
+  // content-hash hit instead of a spurious tsc rebuild. We never seed a package
+  // that is currently missing/stale (those still build below and record then).
+  if (useContentCache) {
+    const staleNames = new Set(missingOrStale.map((pkg) => pkg.name));
+    const cache = cacheOptions.artifactCache;
+    const toSeed = REQUIRED_BUILD_PACKAGES.filter(
+      (pkg) =>
+        pkg.staleAgainstGlobs?.length &&
+        !staleNames.has(pkg.name) &&
+        !cache?.entries?.[pkg.name]?.sourceHash,
+    );
+    if (toSeed.length > 0) {
+      recordArtifactBuild(toSeed, resolvedRootDir, cacheOptions.gitFn ?? defaultGitRunner);
+    }
+  }
+
   if (missingOrStale.length === 0) return [];
 
   const names = missingOrStale.map((pkg) => pkg.name);
@@ -234,6 +370,13 @@ export function ensureTestArtifacts(
   } else {
     runFn("pnpm", [...names.flatMap((name) => ["--filter", name]), "build"], resolvedRootDir);
   }
+
+  // Build succeeded (the real runner exits the process on failure, so reaching
+  // here means a clean build). Record content hashes for the packages we built
+  // so the next run can skip the rebuild on unchanged content.
+  if (useContentCache) {
+    recordArtifactBuild(missingOrStale, resolvedRootDir, cacheOptions.gitFn ?? defaultGitRunner);
+  }
   return names;
 }
 

scripts/lib/content-hash.mjs

@@ -0,0 +1,177 @@
+/**
+ * Shared content-hashing helpers for the inner-loop overhead caches (U3).
+ *
+ * The goal is a hash that:
+ *   - Is cheap to compute (defers to git's already-computed blob SHAs).
+ *   - Is branch-switch stable: restoring identical content under a different
+ *     branch yields the same hash, so we don't re-run work that already passed.
+ *   - Still busts on real content changes, INCLUDING unstaged/working-tree edits
+ *     and untracked files (git ls-files -s only sees the index, not the working
+ *     tree). For those "dirty" files we hash the working-tree bytes directly.
+ *
+ * Correctness-over-speed: when a tracked file is modified in the working tree we
+ * read and hash its actual bytes rather than trusting the (now stale) index blob
+ * SHA. Untracked-but-not-ignored files are likewise read and hashed. Only when a
+ * path is fully clean do we lean on git's blob SHA without touching the file.
+ */
+
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import path from "node:path";
+
+/**
+ * Default git runner. Returns trimmed stdout on success, null on failure.
+ *
+ * @param {string[]} args
+ * @param {string} cwd
+ * @returns {string|null}
+ */
+export function defaultGitRunner(args, cwd) {
+  const result = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  if (result.status !== 0) return null;
+  return result.stdout.trim();
+}
+
+/**
+ * Parse `git ls-files -s <paths...>` output into { filePath, blobSha } records.
+ *
+ * @param {string|null} lsOut
+ * @returns {{ filePath: string, blobSha: string }[]}
+ */
+function parseLsFiles(lsOut) {
+  const entries = [];
+  if (!lsOut) return entries;
+  for (const line of lsOut.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    // Format: <mode> SP <object> SP <stage> TAB <file>
+    const tabIdx = trimmed.indexOf("\t");
+    if (tabIdx === -1) continue;
+    const fields = trimmed.slice(0, tabIdx).split(/\s+/);
+    const blobSha = fields[1] ?? "";
+    const filePath = trimmed.slice(tabIdx + 1);
+    entries.push({ filePath, blobSha });
+  }
+  return entries;
+}
+
+/**
+ * Compute a content hash over the given repo-relative input paths.
+ *
+ * Each path may be a file or a directory; git expands directories to their
+ * tracked files. Dirty (modified-tracked) and untracked-not-ignored files have
+ * their working-tree bytes hashed so the hash reflects real on-disk content,
+ * never a stale index blob SHA.
+ *
+ * @param {object} options
+ * @param {string} options.rootDir          Repo root (cwd for git).
+ * @param {string[]} options.inputPaths     Repo-relative files/dirs to hash.
+ * @param {string} [options.versionPrefix]  Constant mixed in to bust on format change.
+ * @param {(args: string[], cwd: string) => string|null} [options.gitFn]  Injectable git.
+ * @param {(absPath: string) => Buffer|string} [options.readFn]  Injectable file reader.
+ * @returns {string} 64-char hex SHA-256.
+ */
+export function computeContentHash({
+  rootDir,
+  inputPaths,
+  versionPrefix = "ch-v1",
+  gitFn = defaultGitRunner,
+  readFn = (absPath) => readFileSync(absPath),
+}) {
+  const hash = createHash("sha256");
+  hash.update(versionPrefix);
+  hash.update("\0");
+
+  // Tracked files (index blob SHAs) for every input path.
+  const tracked = parseLsFiles(gitFn(["ls-files", "-s", "--", ...inputPaths], rootDir));
+  const trackedByPath = new Map(tracked.map((entry) => [entry.filePath, entry.blobSha]));
+
+  // Working-tree status: which tracked files are modified, which are untracked.
+  // `git status --porcelain -uall -- <paths>` reports both. Untracked entries
+  // are prefixed with `??`; modified-tracked with ` M`/`M `/etc.
+  const dirtyPaths = new Set();
+  const untrackedPaths = new Set();
+  const statusOut = gitFn(["status", "--porcelain", "-uall", "--", ...inputPaths], rootDir);
+  if (statusOut) {
+    for (const rawLine of statusOut.split("\n")) {
+      if (!rawLine) continue;
+      // Porcelain v1 lines are "XY PATH" where XY is the 2-char status code.
+      // Rather than slice a fixed column (git's exact spacing varies subtly by
+      // staged/worktree state), take the first 2 chars as the code and trim the
+      // remainder for the path.
+      const code = rawLine.slice(0, 2);
+      let file = rawLine.slice(2).replace(/^\s+/, "");
+      // Renames show "old -> new"; hash the new path.
+      const arrowIdx = file.indexOf(" -> ");
+      if (arrowIdx !== -1) file = file.slice(arrowIdx + 4);
+      // Strip optional surrounding quotes git adds for unusual filenames.
+      file = file.replace(/^"|"$/g, "");
+      if (code === "??") {
+        untrackedPaths.add(file);
+      } else {
+        dirtyPaths.add(file);
+      }
+    }
+  }
+
+  // Build the full path list: every tracked file plus every untracked file.
+  const allPaths = new Set([...trackedByPath.keys(), ...untrackedPaths]);
+  const sorted = [...allPaths].sort((a, b) => a.localeCompare(b));
+
+  for (const filePath of sorted) {
+    hash.update(filePath);
+    hash.update("=");
+    const isDirty = dirtyPaths.has(filePath) || untrackedPaths.has(filePath);
+    if (isDirty) {
+      // Hash real on-disk bytes — index blob SHA is stale or absent.
+      try {
+        const bytes = readFn(path.join(rootDir, filePath));
+        const fileHash = createHash("sha256").update(bytes).digest("hex");
+        hash.update("dirty:");
+        hash.update(fileHash);
+      } catch {
+        // File vanished mid-scan (transient). Mix in a marker so the hash
+        // differs from the clean case and forces a re-run.
+        hash.update("dirty:missing");
+      }
+    } else {
+      hash.update(trackedByPath.get(filePath) ?? "");
+    }
+    hash.update("\0");
+  }
+
+  return hash.digest("hex");
+}
+
+/**
+ * Read a JSON cache file, returning a fallback on any failure.
+ *
+ * @param {string} filePath
+ * @param {unknown} fallback
+ * @returns {unknown}
+ */
+export function readJsonCache(filePath, fallback) {
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+/**
+ * Resolve the shared fusion cache directory (same dir as test-cache.json).
+ *
+ * @param {string} rootDir
+ * @returns {string}
+ */
+export function fusionCacheDir(rootDir) {
+  return path.join(rootDir, "node_modules", ".cache", "fusion");
+}
+
+/** Re-export statSync passthrough so callers can stub uniformly if needed. */
+export { statSync };

scripts/sync-fusion-skill-tools.mjs

@@ -14,9 +14,14 @@
  *   node scripts/sync-fusion-skill-tools.mjs --check
  */
 
-import { readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { dirname, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
+import {
+  computeContentHash,
+  fusionCacheDir,
+  readJsonCache,
+} from "./lib/content-hash.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const repoRoot = resolve(__dirname, "..");
@@ -31,6 +36,87 @@ const capabilitiesPath = resolve(
   "packages/cli/skill/fusion/references/fusion-capabilities.md",
 );
 
+// ---------------------------------------------------------------------------
+// U3: skip-the-spawn cache for the --check path.
+//
+// The inner loop (scripts/test-changed.mjs) used to spawn this script on every
+// `pnpm test`. The --check pass is deterministic over a small, fixed set of
+// inputs: the extension source of truth, the three generated docs, and this
+// script itself (its logic affects the output). When none of those have changed
+// since the last passing --check, the spawn is pure overhead. We cache the
+// content hash of those inputs after a clean --check and let the caller skip
+// spawning when the hash is unchanged.
+// ---------------------------------------------------------------------------
+
+/** Repo-relative input paths whose content determines the --check result. */
+export const SKILL_SYNC_INPUT_PATHS = [
+  "packages/cli/src/extension.ts",
+  "packages/cli/skill/fusion/SKILL.md",
+  "packages/cli/skill/fusion/references/extension-tools.md",
+  "packages/cli/skill/fusion/references/fusion-capabilities.md",
+  "scripts/sync-fusion-skill-tools.mjs",
+];
+
+const SKILL_SYNC_CACHE_VERSION = 1;
+
+function skillSyncCachePath(rootDir = repoRoot) {
+  return join(fusionCacheDir(rootDir), "skill-sync-cache.json");
+}
+
+/**
+ * Compute the content hash over the skill-sync inputs.
+ *
+ * @param {string} [rootDir]
+ * @param {object} [deps]  Injectable git/read fns for tests.
+ * @returns {string}
+ */
+export function computeSkillSyncHash(rootDir = repoRoot, deps = {}) {
+  return computeContentHash({
+    rootDir,
+    inputPaths: SKILL_SYNC_INPUT_PATHS,
+    versionPrefix: `skill-sync-v${SKILL_SYNC_CACHE_VERSION}`,
+    ...deps,
+  });
+}
+
+/**
+ * Return true when a clean --check is already cached for the current inputs, so
+ * the caller can skip spawning the check entirely. Full runs (CI / --full)
+ * bypass this and always run.
+ *
+ * @param {string} [rootDir]
+ * @param {object} [deps]
+ * @returns {boolean}
+ */
+export function isSkillSyncCheckCached(rootDir = repoRoot, deps = {}) {
+  const cache = readJsonCache(skillSyncCachePath(rootDir), null);
+  if (!cache || cache.version !== SKILL_SYNC_CACHE_VERSION || typeof cache.hash !== "string") {
+    return false;
+  }
+  return cache.hash === computeSkillSyncHash(rootDir, deps);
+}
+
+/**
+ * Persist a passing --check result so the next run can skip the spawn.
+ *
+ * @param {string} [rootDir]
+ * @param {object} [deps]
+ */
+export function recordSkillSyncCheckPass(rootDir = repoRoot, deps = {}) {
+  try {
+    const dir = fusionCacheDir(rootDir);
+    mkdirSync(dir, { recursive: true });
+    const payload = {
+      version: SKILL_SYNC_CACHE_VERSION,
+      hash: computeSkillSyncHash(rootDir, deps),
+      passedAt: new Date().toISOString(),
+    };
+    writeFileSync(skillSyncCachePath(rootDir), JSON.stringify(payload, null, 2));
+  } catch {
+    // Cache is an optimization; a write failure just means we spawn next time.
+  }
+}
+
 const SKILL_BEGIN =
   "<!-- BEGIN: tool-categories (auto-generated by scripts/sync-fusion-skill-tools.mjs — do not edit by hand) -->";
 const SKILL_END = "<!-- END: tool-categories -->";
@@ -502,6 +588,8 @@ function main() {
       );
       process.exit(1);
     }
+    // U3: cache the passing result so the inner loop can skip the next spawn.
+    recordSkillSyncCheckPass(repoRoot);
     return;
   }
 
@@ -517,4 +605,8 @@ function main() {
   );
 }
 
-main();
+// Only run the sync when invoked directly as a script — importing the module
+// (e.g. from tests for the cache helpers) must not trigger a full sync.
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main();
+}

scripts/test-changed.mjs

@@ -8,6 +8,7 @@ import { createHash } from "node:crypto";
 import { cpus, tmpdir } from "node:os";
 import { createRequire } from "node:module";
 import { ensureTestArtifacts } from "./ensure-test-artifacts.mjs";
+import { isSkillSyncCheckCached } from "./sync-fusion-skill-tools.mjs";
 
 const currentFilePath = fileURLToPath(import.meta.url);
 const scriptDir = path.dirname(currentFilePath);
@@ -107,9 +108,13 @@ function run(command, commandArgs, options = {}) {
   }
 }
 
-function runIsolationCheck(before = false, env = process.env) {
+function runIsolationCheck(before = false, env = process.env, fastBefore = false) {
   const args = [checkIsolationScript];
-  if (before) args.push("--before");
+  // U3: the before-pass is the costly one (2s mutability probe). Use the cheap
+  // `--before-fast` variant, which reuses the prior run's externally-active
+  // classification and skips the probe. The script falls back to the full probe
+  // when no prior baseline exists, so detection is never weakened.
+  if (before) args.push(fastBefore ? "--before-fast" : "--before");
   // Inject the names of every isolated HOME this script created so the check
   // never reports them as a leak even if the rm-rf in cleanup silently failed
   // or the baseline file got rotated mid-run. Without this, a transient EBUSY
@@ -126,7 +131,14 @@ export function shouldRunIsolationGuard(env = process.env) {
   return env.FUSION_TEST_DISABLE_ISOLATION_GUARD !== "1";
 }
 
-function pruneFusionTestHomes() {
+// U3: bound the prune scan. It only ever targets our own
+// `fusion-test-home-root-*` prefix (it always did), but we additionally cap the
+// number of entries removed per call and skip very-fresh dirs, so a single run
+// can't spend unbounded time rm-rf'ing a tmpdir that accumulated thousands of
+// stale homes — and so the cache-fresh fast path can skip it entirely.
+const PRUNE_MAX_ENTRIES = 64;
+
+export function pruneFusionTestHomes(maxEntries = PRUNE_MAX_ENTRIES) {
   let tmpEntries = [];
   try {
     tmpEntries = readdirSync(tmpdir(), { withFileTypes: true });
@@ -134,17 +146,19 @@ function pruneFusionTestHomes() {
     return;
   }
 
+  let removed = 0;
   for (const entry of tmpEntries) {
+    if (removed >= maxEntries) break;
     if (!entry.isDirectory() || !entry.name.startsWith("fusion-test-home-root-")) continue;
     const rawPath = path.join(tmpdir(), entry.name);
-    let resolvedPath = rawPath;
     try {
-      resolvedPath = realpathSync(rawPath);
+      realpathSync(rawPath);
     } catch {
       // Keep raw path fallback.
     }
     try {
       rmSync(rawPath, { recursive: true, force: true });
+      removed++;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       console.warn(`[test-changed] failed to prune leftover ${rawPath}: ${message}`);
@@ -156,7 +170,7 @@ function runMaybeIsolated(command, commandArgs, options = {}) {
   const enabled = shouldRunIsolationGuard();
   const env = options.env ?? process.env;
   const { onBeforeAfterCheck, ...spawnOptions } = options;
-  if (enabled) runIsolationCheck(true, env);
+  if (enabled) runIsolationCheck(true, env, /* fastBefore */ true);
   try {
     run(command, commandArgs, spawnOptions);
   } finally {
@@ -903,17 +917,9 @@ export function main(argv = process.argv.slice(2)) {
     return;
   }
 
-  run("pnpm", ["sync:fusion-skill:check"]);
-  ensureTestArtifacts(rootDir);
-
-  const { env: isolatedHomeEnv, isolatedHome } = createIsolatedHomeEnv(fullSuiteEnv);
-
-  const cleanupIsolatedHome = () => {
-    cleanupIsolatedHomePath(isolatedHome);
-  };
-
-  try {
-
+  // Decide the execution plan and apply the cache BEFORE paying any fixed setup
+  // cost. The cache-fresh fast path can then skip the skill-sync spawn, the
+  // artifact-ensure pass, isolated-HOME creation, and the prune scan entirely.
   const baseBranch = getBaseBranch();
   const comparisonBase = detectComparisonBase(baseBranch);
   const changedFiles = comparisonBase ? changedFilesSince(comparisonBase) : null;
@@ -933,6 +939,57 @@ export function main(argv = process.argv.slice(2)) {
   // R5: structured mode-decision telemetry so fast-path hit rate is observable.
   emitModeDecision(plan);
 
+  // For changed plans, resolve the cache now so we know whether any package
+  // actually needs running before we spend setup time.
+  let cachedPackages = [];
+  let activePackages = plan.packages ?? [];
+  if (plan.mode === "changed") {
+    ({ cachedPackages, activePackages } = applyCacheToPlan(plan, {
+      noCache: noCache || forceFullSuite,
+      packageDirByName,
+    }));
+  }
+
+  const hasWork = plan.mode === "full" || activePackages.length > 0;
+
+  // Cache-fresh fast path: nothing to run. Emit a fast-path mode line, run only
+  // the (now cheap) isolation guard, and skip skill-sync, artifact-ensure,
+  // HOME creation, and prune.
+  if (!hasWork) {
+    console.log("[test-changed] fast-path=cache-fresh (no packages to run).");
+    console.log(
+      `[test-changed] all changed packages are cache-fresh (${cachedPackages.join(", ")}); nothing to run.`,
+    );
+    if (shouldRunIsolationGuard()) {
+      // No isolated HOME was created and no tests ran, so there is nothing to
+      // prune and no real risk of a leak — but we still run a single cheap
+      // before/after guard pass to preserve the invariant that every `pnpm test`
+      // verifies isolation.
+      runIsolationCheck(true, process.env, /* fastBefore */ true);
+      runIsolationCheck(false, process.env);
+    }
+    return;
+  }
+
+  // There is work to do — pay the fixed setup cost now.
+  // U3: skip the skill-sync check spawn when its inputs are unchanged since the
+  // last passing run. Full runs (CI / --full) always run it unconditionally so
+  // the gate never goes silent on the path that actually enforces it.
+  if (forceFullSuite || !isSkillSyncCheckCached(rootDir)) {
+    run("pnpm", ["sync:fusion-skill:check"]);
+  } else {
+    console.log("[test-changed] skill-sync check skipped (inputs unchanged since last pass).");
+  }
+  ensureTestArtifacts(rootDir);
+
+  const { env: isolatedHomeEnv, isolatedHome } = createIsolatedHomeEnv(fullSuiteEnv);
+
+  const cleanupIsolatedHome = () => {
+    cleanupIsolatedHomePath(isolatedHome);
+  };
+
+  try {
+
   if (plan.mode === "full") {
     if (plan.reason === "missing-comparison-base") {
       console.log(`[test-changed] could not resolve merge-base with ${baseBranch}; running full suite.`);
@@ -953,24 +1010,6 @@ export function main(argv = process.argv.slice(2)) {
     return;
   }
 
-  // Apply the content-hash cache to prune already-passing packages.
-  const { cachedPackages, activePackages } = applyCacheToPlan(plan, {
-    noCache: noCache || forceFullSuite,
-    packageDirByName,
-  });
-
-  if (activePackages.length === 0) {
-    console.log(
-      `[test-changed] all changed packages are cache-fresh (${cachedPackages.join(", ")}); nothing to run.`,
-    );
-    if (shouldRunIsolationGuard()) {
-      runIsolationCheck(true, isolatedHomeEnv);
-      cleanupIsolatedHome();
-      runIsolationCheck(false, isolatedHomeEnv);
-    }
-    return;
-  }
-
   const filterArgs = activePackages.flatMap((pkg) => ["--filter", pkg]);
   console.log(`[test-changed] running tests for changed packages: ${activePackages.join(", ")}`);
   if (cachedPackages.length > 0) {