diff --git a/config.json b/config.json
index e4ecbec..60f68c3 100644
--- a/config.json
+++ b/config.json
@@ -164,6 +164,14 @@
         "prerequisites": [],
         "difficulty": 2
       },
+      {
+        "slug": "phone-number",
+        "name": "Phone Number",
+        "uuid": "56086c2e-fc29-4bf2-810d-a3bfd9acb995",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 2
+      },
       {
         "slug": "raindrops",
         "name": "Raindrops",
diff --git a/exercises/practice/phone-number/.docs/instructions.md b/exercises/practice/phone-number/.docs/instructions.md
new file mode 100644
index 0000000..5d4d373
--- /dev/null
+++ b/exercises/practice/phone-number/.docs/instructions.md
@@ -0,0 +1,34 @@
+# Instructions
+
+Clean up phone numbers so that they can be sent SMS messages.
+
+The **North American Numbering Plan (NANP)** is a telephone numbering system used by many countries in North America like the United States, Canada or Bermuda.
+All NANP-countries share the same international country code: `1`.
+
+NANP numbers are ten-digit numbers consisting of a three-digit Numbering Plan Area code, commonly known as _area code_, followed by a seven-digit local number.
+The first three digits of the local number represent the _exchange code_, followed by the unique four-digit number which is the _subscriber number_.
+
+The format is usually represented as
+
+```text
+NXX NXX-XXXX
+```
+
+where `N` is any digit from 2 through 9 and `X` is any digit from 0 through 9.
+
+Sometimes they also have the country code (represented as `1` or `+1`) prefixed.
+
+Your task is to clean up differently formatted telephone numbers by removing punctuation and the country code if present.
+
+For example, the inputs
+
+- `+1 (613)-995-0253`
+- `613-995-0253`
+- `1 613 995 0253`
+- `613.995.0253`
+
+should all produce the output
+
+`6139950253`
+
+**Note:** As this exercise only deals with telephone numbers used in NANP-countries, only 1 is considered a valid country code.
diff --git a/exercises/practice/phone-number/.docs/introduction.md b/exercises/practice/phone-number/.docs/introduction.md
new file mode 100644
index 0000000..c4142c5
--- /dev/null
+++ b/exercises/practice/phone-number/.docs/introduction.md
@@ -0,0 +1,12 @@
+# Introduction
+
+You've joined LinkLine, a leading communications company working to ensure reliable connections for everyone.
+The team faces a big challenge: users submit phone numbers in all sorts of formats — dashes, spaces, dots, parentheses, and even prefixes.
+Some numbers are valid, while others are impossible to use.
+
+Your mission is to turn this chaos into order.
+You'll clean up valid numbers, formatting them appropriately for use in the system.
+At the same time, you'll identify and filter out any invalid entries.
+
+The success of LinkLine's operations depends on your ability to separate the useful from the unusable.
+Are you ready to take on the challenge and keep the connections running smoothly?
diff --git a/exercises/practice/phone-number/.meta/config.json b/exercises/practice/phone-number/.meta/config.json
new file mode 100644
index 0000000..edcfef7
--- /dev/null
+++ b/exercises/practice/phone-number/.meta/config.json
@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "IsaacG"
+  ],
+  "files": {
+    "solution": [
+      "phone_number.gd"
+    ],
+    "test": [
+      "phone_number_test.gd"
+    ],
+    "example": [
+      ".meta/example.gd"
+    ]
+  },
+  "blurb": "Clean up user-entered phone numbers so that they can be sent SMS messages.",
+  "source": "Exercise by the JumpstartLab team for students at The Turing School of Software and Design.",
+  "source_url": "https://www.turing.edu/"
+}
diff --git a/exercises/practice/phone-number/.meta/example.gd b/exercises/practice/phone-number/.meta/example.gd
new file mode 100644
index 0000000..f127df1
--- /dev/null
+++ b/exercises/practice/phone-number/.meta/example.gd
@@ -0,0 +1,9 @@
+func clean(number: String):
+	number = number.replace("(", "").replace(")", "").replace("-", "").replace(".", "").replace(" ", "").replace("+", "")
+	if len(number) == 11 and number.begins_with("1"):
+		number = number.substr(1)
+	if len(number) != 10 or not number.is_valid_int():
+		return "Invalid input"
+	if number[0] in "01" or number[3] in "01":
+		return "Invalid input"
+	return number
diff --git a/exercises/practice/phone-number/.meta/template.j2 b/exercises/practice/phone-number/.meta/template.j2
new file mode 100644
index 0000000..7472d31
--- /dev/null
+++ b/exercises/practice/phone-number/.meta/template.j2
@@ -0,0 +1,12 @@
+{% for case in cases %}
+func test_{{ case.func_name }}(solution_script):
+	var got = solution_script.{{ case.property }}({{ case.given | togdscript }})
+{%- if not case.expect_error %}
+	var want = {{ case.expected | togdscript }}
+{%- else %}
+	var want = "Invalid input"
+{%- endif %}
+	return [got, want]
+
+{% endfor %}
+
diff --git a/exercises/practice/phone-number/.meta/tests.toml b/exercises/practice/phone-number/.meta/tests.toml
new file mode 100644
index 0000000..24dbf07
--- /dev/null
+++ b/exercises/practice/phone-number/.meta/tests.toml
@@ -0,0 +1,84 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[79666dce-e0f1-46de-95a1-563802913c35]
+description = "cleans the number"
+
+[c360451f-549f-43e4-8aba-fdf6cb0bf83f]
+description = "cleans numbers with dots"
+
+[08f94c34-9a37-46a2-a123-2a8e9727395d]
+description = "cleans numbers with multiple spaces"
+
+[598d8432-0659-4019-a78b-1c6a73691d21]
+description = "invalid when 9 digits"
+include = false
+
+[2de74156-f646-42b5-8638-0ef1d8b58bc2]
+description = "invalid when 9 digits"
+reimplements = "598d8432-0659-4019-a78b-1c6a73691d21"
+
+[57061c72-07b5-431f-9766-d97da7c4399d]
+description = "invalid when 11 digits does not start with a 1"
+
+[9962cbf3-97bb-4118-ba9b-38ff49c64430]
+description = "valid when 11 digits and starting with 1"
+
+[fa724fbf-054c-4d91-95da-f65ab5b6dbca]
+description = "valid when 11 digits and starting with 1 even with punctuation"
+
+[c6a5f007-895a-4fc5-90bc-a7e70f9b5cad]
+description = "invalid when more than 11 digits"
+include = false
+
+[4a1509b7-8953-4eec-981b-c483358ff531]
+description = "invalid when more than 11 digits"
+reimplements = "c6a5f007-895a-4fc5-90bc-a7e70f9b5cad"
+
+[63f38f37-53f6-4a5f-bd86-e9b404f10a60]
+description = "invalid with letters"
+include = false
+
+[eb8a1fc0-64e5-46d3-b0c6-33184208e28a]
+description = "invalid with letters"
+reimplements = "63f38f37-53f6-4a5f-bd86-e9b404f10a60"
+
+[4bd97d90-52fd-45d3-b0db-06ab95b1244e]
+description = "invalid with punctuations"
+include = false
+
+[065f6363-8394-4759-b080-e6c8c351dd1f]
+description = "invalid with punctuations"
+reimplements = "4bd97d90-52fd-45d3-b0db-06ab95b1244e"
+
+[d77d07f8-873c-4b17-8978-5f66139bf7d7]
+description = "invalid if area code starts with 0"
+
+[c7485cfb-1e7b-4081-8e96-8cdb3b77f15e]
+description = "invalid if area code starts with 1"
+
+[4d622293-6976-413d-b8bf-dd8a94d4e2ac]
+description = "invalid if exchange code starts with 0"
+
+[4cef57b4-7d8e-43aa-8328-1e1b89001262]
+description = "invalid if exchange code starts with 1"
+
+[9925b09c-1a0d-4960-a197-5d163cbe308c]
+description = "invalid if area code starts with 0 on valid 11-digit number"
+
+[3f809d37-40f3-44b5-ad90-535838b1a816]
+description = "invalid if area code starts with 1 on valid 11-digit number"
+
+[e08e5532-d621-40d4-b0cc-96c159276b65]
+description = "invalid if exchange code starts with 0 on valid 11-digit number"
+
+[57b32f3d-696a-455c-8bf1-137b6d171cdf]
+description = "invalid if exchange code starts with 1 on valid 11-digit number"
diff --git a/exercises/practice/phone-number/lib/test_runner.gd b/exercises/practice/phone-number/lib/test_runner.gd
new file mode 100644
index 0000000..9274583
--- /dev/null
+++ b/exercises/practice/phone-number/lib/test_runner.gd
@@ -0,0 +1,467 @@
+class_name TestRunner
+extends SceneTree
+
+class ErrorReader:
+	"""ErrorReader reads from a STDERR file (cmd 2>/file).
+
+	It filters out the less useful Godot output and handles retrieving lines iteratively.
+	"""
+
+	const EXPECTED_GODOT_ERRORS = [
+		"ERROR: Could not create directory: /root/.local\n   at: make_dir_recursive (core/io/dir_access.cpp:180)\n",
+		"ERROR: Error attempting to create data dir: /root/.local/share/godot/app_userdata/[unnamed project].\n   at: ensure_user_data_dir (core/os/os.cpp:344)\n",
+		"ERROR: Could not create editor data directory: /root/.local/share/godot\n   at: EditorPaths (editor/editor_paths.cpp:183)\n",
+		"ERROR: Could not create directory: /root/.config\n   at: make_dir_recursive (core/io/dir_access.cpp:180)\n",
+		"ERROR: Could not create editor config directory: /root/.config/godot\n   at: EditorPaths (editor/editor_paths.cpp:198)\n",
+		"ERROR: Could not create directory: /root/.cache\n   at: make_dir_recursive (core/io/dir_access.cpp:180)\n",
+		"ERROR: Could not create editor cache directory: /root/.cache/godot\n   at: EditorPaths (editor/editor_paths.cpp:219)\n",
+		"ERROR: Can't save resource to empty path. Provide non-empty path or a Resource with non-empty resource_path.\n   at: save (core/io/resource_saver.cpp:105)\n",
+		"ERROR: Error saving editor settings to \n   at: save (editor/editor_settings.cpp:1013)\n",
+	]
+	var already_processed_bytes: int = 0
+	var filename: String = ""
+	var color_sequence = RegEx.create_from_string("\\e\\[\\d[\\d;]*m")
+
+	func _init(filename: String) -> void:
+		self.already_processed_bytes = 0
+		self.filename = filename
+		if not self.filename.is_empty() and ResourceLoader.exists(self.filename):
+			self.get_error_message()
+
+	func check() -> Error:
+		if not FileAccess.file_exists(self.filename):
+			push_error("STDERR must be redirected to '%s' when using '--json'" % self.filename)
+			return ERR_FILE_NOT_FOUND
+		if OS.get_stderr_type() != OS.STD_HANDLE_FILE:
+			push_error("STDERR must be redirected to '%s' when using '--json'" % self.filename)
+			return ERR_FILE_NOT_FOUND
+		return OK
+
+	func get_error_message() -> String:
+		"""
+		Checks the contents of the STDERR file, where error output from the
+		currently running test suite should be stored. If there is any relevant output
+		there, this method will return it. If the file is empty, an empty string is returned.
+
+		This method will remove previously read output from the returned message. It should
+		be called after executing every test, to ensure that the message contains only output
+		relevant for the given test.
+
+		NOTE: running a Godot instance without full access to certain folders in the
+		home directory (`~/.config`, `~/.local`, `~/.cache`) will result in additional
+		errors. This happens when GDScript test runner is executed in Docker. However,
+		these errors do not stop the execution of the program, so they can be ignored.
+		This method filters them out, leaving only the errors caused by the actual tests.
+		"""
+		if self.filename.is_empty():
+			return ""
+
+		var error_output = FileAccess.get_file_as_string(self.filename)
+		error_output = error_output.erase(0, self.already_processed_bytes)
+		self.already_processed_bytes += len(error_output)
+
+		# By default, Godot's error messages are printed with colors. To include the output in the
+		# `results.json` file, color markers need to be removed first.
+		error_output = self.color_sequence.sub(error_output, "", true)
+
+		# Filter out the expected error messages
+		for expected_error in EXPECTED_GODOT_ERRORS:
+			error_output = error_output.replace(expected_error, "")
+
+		return error_output
+
+
+class ResultWriter:
+
+	var json_file: String = ""
+	var stderr: ErrorReader = null
+
+	func _init(json_file: String, stderr: ErrorReader) -> void:
+		self.json_file = json_file
+		self.stderr = stderr
+
+	func delete_existing() -> Error:
+		"""
+		Removes the previous `results.json` file, to ensure that the current test suite will not use it.
+		"""
+		if self.json_file.is_empty():
+			return OK
+		if FileAccess.file_exists(self.json_file):
+			DirAccess.remove_absolute(self.json_file)
+		var error_message: String = self.stderr.get_error_message()
+		if not error_message.is_empty():
+			push_error(error_message)
+			return FAILED
+		return OK
+
+	func write(results: Dictionary) -> Error:
+		"""
+		If output_dir_path is empty, outputs friendly-formatted test results to
+		stdout.
+
+		Otherwise, writes JSON results to results.json in the given path.
+		"""
+		if self.json_file.is_empty():
+			return print_friendly_results(results)
+		else:
+			return write_results_file(results)
+
+	func print_friendly_results(results: Dictionary) -> Error:
+		"""
+		Prints rich results to stdout.
+		"""
+		var rich_results = [""]
+		if results.status == "pass":
+			rich_results.push_back("[color=yellow]Exercise passed!  Nicely done![/color]")
+		else:
+			rich_results.push_back("Exercise has at least one failed test:")
+			for test in results.tests:
+				if test.status == "pass":
+					rich_results.push_back(" %s [color=yellow]passed ✔[/color]" % test.name)
+				else:
+					rich_results.push_back(" %s [color=pink]failed: %s[/color]" % [test.name, test.message])
+		print_rich("\n".join(rich_results))
+		return OK
+
+	func write_results_file(results: Dictionary) -> Error:
+		"""
+		Saves a dictionary as a `results.json` file in the output directory. The file
+		is indented with 4 spaces, keys are not sorted.
+
+		The `results` dictionary represents the full output of a single exercise's
+		test suite, according to the Test Runner Interface documentation:
+
+		https://exercism.org/docs/building/tooling/test-runners/interface
+
+		This method automatically adds `'version' = 2` to the results.
+		"""
+		# Due to keys not being sorted, `version` should be inserted first
+		var full_results = {"version": 2}
+		full_results.merge(results)
+
+		var pretty_results = JSON.stringify(full_results, "  ", false)
+
+		var results_json = FileAccess.open(self.json_file, FileAccess.WRITE)
+		if results_json == null:
+			var err = FileAccess.get_open_error()
+			push_error("Failed to write the file: %s (%s)" % [self.json_file, error_string(err)])
+			return err
+
+		results_json.store_string(pretty_results + "\n")
+		return OK
+
+
+class ArgParser:
+	"""ArgParser reads the cmdline and parses inputs and options."""
+
+	var solution_script_path: String = ""
+	var test_suite_script_path: String = ""
+	var run_all: bool = false
+	var json: bool = false
+	var json_file: String = ""
+
+	func usage(message: String) -> void:
+		print("Usage:")
+		print("test_runner [--all] [--json filename.json] <slug> <solution_directory>")
+		if not message.is_empty():
+			print()
+			print(message)
+
+	func parse_args() -> Error:
+		"""
+		Validates the number of args passed to the script and sets values of the following
+		global variables, based on the given args:
+		* `solution_script_path`
+		* `test_suite_script_path`
+		"""
+		var args = OS.get_cmdline_user_args()
+		var positional: Array = []
+
+		var idx := 0
+		while idx < len(args):
+			var arg = args[idx]
+			if arg == "--all":
+				run_all = true
+			elif arg.begins_with("--json"):
+				if arg.contains("="):
+					var parts = arg.split("=", true, 1)
+					if parts[0] == "--json":
+						self.json = true
+						self.json_file = parts[1]
+					else:
+						usage("Invalid flag %s" % arg)
+						return ERR_INVALID_PARAMETER
+				elif idx + 1 < len(args):
+					self.json = true
+					self.json_file = args[idx + 1]
+					idx += 1
+				else:
+					usage("Flag %s is missing a filename" % arg)
+					return ERR_INVALID_PARAMETER
+			elif arg.begins_with("--"):
+				usage("Invalid flag %s" % arg)
+				return ERR_INVALID_PARAMETER
+			else:
+				positional.append(arg)
+			idx += 1
+
+		if len(positional) != 2:
+			usage("Expecting 2 positional args but got %d" % len(positional))
+			return ERR_INVALID_PARAMETER
+
+		var slug = positional[0]
+		var solution_dir_path = positional[1]
+
+		# Test folders use dashes, but test files use underscores
+		var gdscript_path = solution_dir_path.path_join(slug.replace("-", "_"))
+
+		self.solution_script_path = gdscript_path + ".gd"
+		self.test_suite_script_path = gdscript_path + "_test.gd"
+
+		return OK
+
+	func files() -> Array:
+		return [self.solution_script_path, self.test_suite_script_path]
+
+
+class Runner:
+
+	var test_suite: Object = null
+	var solution: Object = null
+	var stderr: ErrorReader = null
+	var result_writer: ResultWriter = null
+
+	func _init(test_suite: Object, solution: Object, stderr: ErrorReader, result_writer: ResultWriter) -> void:
+		self.test_suite = test_suite
+		self.solution = solution
+		self.stderr = stderr
+		self.result_writer = result_writer
+
+	func extract_methods() -> Dictionary:
+		"""Extract the source code of a method from a script."""
+		var in_func: bool = false
+		var parts = []
+		var methods: Dictionary = {}
+		var name: String = ""
+		var func_re: RegEx = RegEx.create_from_string('^func ([^(]+)\\(')
+		for line in self.test_suite.get_script().source_code.split("\n"):
+			if not in_func:
+				var matched = func_re.search(line)
+				if matched:
+					in_func = true
+					name = matched.get_strings()[1]
+					parts = []
+			elif not line.begins_with("\t") and not line.begins_with(" "):
+				if in_func:
+					in_func = false
+					methods[name] = "\n".join(parts)
+			else:
+				parts.append(line)
+
+		return methods
+
+	func get_failed_test_message(actual, expected) -> String:
+		"""
+		Generates a message for a failed test. If given values are strings,
+		this method will wrap them in single quotes, to distinguish from
+		other types, like integers (e.g. '3' vs 3).
+
+		This method should be used if the actual and expected values for a
+		given test are different, or if they have different types.
+		"""
+		var values = []
+
+		for value in [actual, expected]:
+			var formatted_value = str(value)
+			if typeof(value) == TYPE_STRING:
+				formatted_value = "'{0}'".format([formatted_value])
+			values.append(formatted_value)
+
+		return "Expected output was {1}, actual output was {0}.".format(values)
+
+	func run_tests() -> Array:
+		"""
+		Runs the given test suite agains the given solution script. Returns an Array
+		representing the results of each test case, in the same order that they are defined
+		in the test suite. Each test result is a Dictionary containing 3 values:
+
+		* `name`: the name of the test case
+		* `status`: 'pass', 'fail', or 'error'
+		* `message`: null if the test passed, otherwise it contains the details of the failure/error
+
+		This method will look for methods starting with `test_` in the test script, and
+		then call them with the solution script as the only argument. The `test_` method's
+		name will be used as the `name` value for each test result.
+
+		If any stderr output was generated during the execution of the `test_` method,
+		`status` will be set to 'error'. The test will also receive an 'error' status
+		if calling the `test_` method returned null (which indicates execution issues).
+
+		Otherwise, the `test_` method should return an Array of 2 elements: the actual value,
+		and the expected value. The values will be compared and if they are the same, the test will
+		pass. Otherwise, it will fail, with a relevant message being set by this method.
+		"""
+		var test_results = []
+		var test_codes = self.extract_methods()
+
+		for method in self.test_suite.get_method_list():
+			if not method["name"].begins_with("test_"):
+				continue
+			var test_method_name = method["name"]
+			print("-> " + test_method_name)
+			var test_method = self.test_suite.get(test_method_name)
+
+			var output = test_method.call(self.solution)
+			var error_message = self.stderr.get_error_message()
+
+			if output == null:
+				test_results.append({
+					"name": test_method_name,
+					"status": "error",
+					"message": error_message,
+				})
+			else:
+				var actual = output[0]
+				var expected = output[1]
+
+				var passed = (
+					typeof(actual) == typeof(expected) and
+					actual == expected and
+					error_message.is_empty()
+				)
+
+				var status = "error"
+				if error_message.is_empty():
+					status = "pass" if passed else "fail"
+					error_message = null if passed else self.get_failed_test_message(
+						actual, expected
+					)
+
+				var test_code = test_codes[method["name"]]
+				# The code would be cleaner if the test suite actually checked the values.
+				# Instead, the test suite returns an array with two values which are compared (above).
+				# This `replace()` hides some of that implementation detail by communicating that the
+				# array elements are being compared for equality.
+				test_code = test_code.replace("return [", "assert_equal [")
+				test_code = test_code.replace("\t", "    ")
+				test_code = test_code.dedent().strip_edges()
+
+				test_results.append({
+					"name": test_method_name,
+					"status": status,
+					"message": error_message,
+					"test_code": test_code,
+				})
+
+		return test_results
+
+	func run(run_all: bool) -> void:
+		"""
+		Executes the current suite against the current solution. Stores the results in the
+		`results.json` file in the output dir.
+		"""
+		var test_results = run_tests()
+		var results = {}
+
+		# Check if any tests were executed
+		if len(test_results) == 0:
+			results = {"status": "error", "message": "No tests were executed.", "tests": []}
+		else:
+			results = {"status": "pass", "tests": test_results}
+
+			# If any of the tests failed, change the global status to `fail`
+			for test_result in test_results:
+				if test_result["status"] != "pass":
+					results["status"] = "fail"
+					break
+
+			if not run_all and results["status"] != "pass":
+				var success_count: int = 0
+				for test_result in test_results:
+					if test_result["status"] == "pass":
+						success_count += 1
+
+				var has_failure = false
+				var filtered_results = []
+				for test_result in test_results:
+					if test_result["status"] == "pass":
+						filtered_results.append(test_result)
+					elif not has_failure:
+						has_failure = true
+						test_result["message"] = "Passes %d/%d tests. First failure: %s" % [
+							success_count, len(test_results), test_result["message"],
+						]
+						filtered_results.append(test_result)
+				results["tests"] = filtered_results
+
+		self.result_writer.write(results)
+
+
+func load_script(solution_script_path: String) -> Object:
+	"""Load a script. This helper is needed to catch failures without aborting the error handling."""
+	return load(solution_script_path).new()
+
+
+func load_solution_script(solution_script_path: String, result_writer: ResultWriter, stderr: ErrorReader) -> Array:
+	"""
+	Loads the solution script and saves it in a global variable. In case of any
+	issues, this method will save the `results.json` file with `error` status.
+	"""
+	# Make sure the STDERR file is empty.
+	stderr.get_error_message()
+	var solution_script = load_script(solution_script_path)
+
+	if solution_script == null:
+		var message: String = "The solution file could not be parsed."
+		# Extract the error message, up until the "Failed to load" line
+		# which is specific to the test runner, not the user's solution.
+		var error_message: String = stderr.get_error_message()
+		if not error_message.is_empty():
+			var msg = []
+			var stop = 'ERROR: Failed to load script "%s" with error "Parse error".' % solution_script_path
+			for line in error_message.split("\n"):
+				if line == stop:
+					break
+				msg.append(line)
+			message += "\n" + "\n".join(msg)
+		var results = {"status": "error", "message": message, "tests": []}
+		result_writer.write(results)
+		return [null, ERR_PARSE_ERROR]
+
+	return [solution_script, OK]
+
+
+func _init():
+	# Calling `quit(1)` doesn't stop the program immediately, so a `return` is necessary.
+	# That's why errors are checked directly in `_init()`, instead of calling `quit(1)`
+	# in each method.
+	var args = ArgParser.new()
+	if args.parse_args() != OK:
+		quit(1)
+		return
+	for file in args.files():
+		if not ResourceLoader.exists(file):
+			push_error("File %s not found." % file)
+			quit(1)
+			return
+
+	var stderr = ErrorReader.new("/tmp/stderr")
+	if args.json and stderr.check() != OK:
+		quit(1)
+		return
+
+	var result_writer = ResultWriter.new(args.json_file, stderr)
+	if result_writer.delete_existing() != OK:
+		quit(1)
+		return
+
+	var r = load_solution_script(args.solution_script_path, result_writer, stderr)
+	if r[1] != OK:
+		quit(1)
+		return
+	var solution = r[0]
+
+	var test_suite = load(args.test_suite_script_path).new()
+
+	Runner.new(test_suite, solution, stderr, result_writer).run(args.run_all)
+	quit()
diff --git a/exercises/practice/phone-number/phone_number.gd b/exercises/practice/phone-number/phone_number.gd
new file mode 100644
index 0000000..f4e2074
--- /dev/null
+++ b/exercises/practice/phone-number/phone_number.gd
@@ -0,0 +1,2 @@
+func clean(number: String):
+	pass
diff --git a/exercises/practice/phone-number/phone_number_test.gd b/exercises/practice/phone-number/phone_number_test.gd
new file mode 100644
index 0000000..5f95594
--- /dev/null
+++ b/exercises/practice/phone-number/phone_number_test.gd
@@ -0,0 +1,106 @@
+func test_cleans_the_number(solution_script):
+	var got = solution_script.clean("(223) 456-7890")
+	var want = "2234567890"
+	return [got, want]
+
+
+func test_cleans_numbers_with_dots(solution_script):
+	var got = solution_script.clean("223.456.7890")
+	var want = "2234567890"
+	return [got, want]
+
+
+func test_cleans_numbers_with_multiple_spaces(solution_script):
+	var got = solution_script.clean("223 456   7890   ")
+	var want = "2234567890"
+	return [got, want]
+
+
+func test_invalid_when_9_digits(solution_script):
+	var got = solution_script.clean("123456789")
+	var want = "Invalid input"
+	return [got, want]
+
+
+func test_invalid_when_11_digits_does_not_start_with_a_1(solution_script):
+	var got = solution_script.clean("22234567890")
+	var want = "Invalid input"
+	return [got, want]
+
+
+func test_valid_when_11_digits_and_starting_with_1(solution_script):
+	var got = solution_script.clean("12234567890")
+	var want = "2234567890"
+	return [got, want]
+
+
+func test_valid_when_11_digits_and_starting_with_1_even_with_punctuation(solution_script):
+	var got = solution_script.clean("+1 (223) 456-7890")
+	var want = "2234567890"
+	return [got, want]
+
+
+func test_invalid_when_more_than_11_digits(solution_script):
+	var got = solution_script.clean("321234567890")
+	var want = "Invalid input"
+	return [got, want]
+
+
+func test_invalid_with_letters(solution_script):
+	var got = solution_script.clean("523-abc-7890")
+	var want = "Invalid input"
+	return [got, want]
+
+
+func test_invalid_with_punctuations(solution_script):
+	var got = solution_script.clean("523-@:!-7890")
+	var want = "Invalid input"
+	return [got, want]
+
+
+func test_invalid_if_area_code_starts_with_0(solution_script):
+	var got = solution_script.clean("(023) 456-7890")
+	var want = "Invalid input"
+	return [got, want]
+
+
+func test_invalid_if_area_code_starts_with_1(solution_script):
+	var got = solution_script.clean("(123) 456-7890")
+	var want = "Invalid input"
+	return [got, want]
+
+
+func test_invalid_if_exchange_code_starts_with_0(solution_script):
+	var got = solution_script.clean("(223) 056-7890")
+	var want = "Invalid input"
+	return [got, want]
+
+
+func test_invalid_if_exchange_code_starts_with_1(solution_script):
+	var got = solution_script.clean("(223) 156-7890")
+	var want = "Invalid input"
+	return [got, want]
+
+
+func test_invalid_if_area_code_starts_with_0_on_valid_11_digit_number(solution_script):
+	var got = solution_script.clean("1 (023) 456-7890")
+	var want = "Invalid input"
+	return [got, want]
+
+
+func test_invalid_if_area_code_starts_with_1_on_valid_11_digit_number(solution_script):
+	var got = solution_script.clean("1 (123) 456-7890")
+	var want = "Invalid input"
+	return [got, want]
+
+
+func test_invalid_if_exchange_code_starts_with_0_on_valid_11_digit_number(solution_script):
+	var got = solution_script.clean("1 (223) 056-7890")
+	var want = "Invalid input"
+	return [got, want]
+
+
+func test_invalid_if_exchange_code_starts_with_1_on_valid_11_digit_number(solution_script):
+	var got = solution_script.clean("1 (223) 156-7890")
+	var want = "Invalid input"
+	return [got, want]
diff --git a/exercises/practice/phone-number/run_tests b/exercises/practice/phone-number/run_tests
new file mode 100755
index 0000000..ed18a90
--- /dev/null
+++ b/exercises/practice/phone-number/run_tests
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+slug=${PWD##*/}
+[[ -f "${slug//-/_}.gd" ]] || die "Error! solution file is missing"
+[[ -f "${slug//-/_}_test.gd" ]] || die "Error! test file is missing"
+exec godot --headless --script ./lib/test_runner.gd -- "${slug}" "${PWD}"