rails-worktrees 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0a2cb7e1644d4ec842daf14fcdf96d6b53d810e548d908a6ea651df4ebaface
-  data.tar.gz: 05ae0690974fed85a0862b0fc296681d7de1b037c03d973bef746a1872b62f41
+  metadata.gz: 6f0667430464dedbea994c715a32e64f226048502f6037186f3c90692c5df6e5
+  data.tar.gz: 1f47027f6cdc16431356c43e4809d801a7537db1558d3ab9b25c1299874d1389
 SHA512:
-  metadata.gz: d23f7e9e0e070624ebff11c04f050a88e11ea43b61b893139d337c3df992a4ac3642db5344c491923ee36e94b6864d903dec72cbe8bbbf16c899dd3714bad6c7
-  data.tar.gz: 919e046dd0c73ad18ae90a9dc6745dbe5484f00766c8c58302f4981fa44b9e0a730455fa9eb5c7c07b929d02abb1c448e150e587495941ac4c8a9dcc20c5dc73
+  metadata.gz: 81a835017246e1cab5fd6acf6ef311b4f9beef54912675602fd454c8ed2aa56904b514be908f69cdc2b84110ec8c38d9d49c9abbc974eea1b309aec2fed3c3f9
+  data.tar.gz: 5aad32825be11a64a0095233ed4068eda727da0af5ca0456657e5a4f0aa33f8aa04c0a6a48929a0e7abe97cbbbff9197aa49845c5b6a4acdf207d6c48e8e0796

data/.release-please-manifest.json

@@ -1 +1 @@
-{".":"0.8.0"}
+{".":"0.9.0"}

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.9.0](https://github.com/asjer/rails-worktrees/compare/v0.8.0...v0.9.0) (2026-11-02)
+
+
+### Features
+
+* **config:** support worktrees inside the repo via worktrees_dir ([#61](https://github.com/asjer/rails-worktrees/issues/61)) ([681f325](https://github.com/asjer/rails-worktrees/commit/681f325584b69fc675f7fce045c5cd8baf36eb83))
+* **setup:** install Playwright Chromium for the pinned version ([#66](https://github.com/asjer/rails-worktrees/issues/66)) ([cdbef7c](https://github.com/asjer/rails-worktrees/commit/cdbef7c24f738674dd209af35da25d4f85e038ed))
+* **wt:** add guarded worktree teardown with dry-run ([#63](https://github.com/asjer/rails-worktrees/issues/63)) ([5592830](https://github.com/asjer/rails-worktrees/commit/5592830849b098e0d904d70cf96390dc55083356))
+
+
+### Bug Fixes
+
+* **wt:** reserve help and version instead of using them as names ([#60](https://github.com/asjer/rails-worktrees/issues/60)) ([d52dba8](https://github.com/asjer/rails-worktrees/commit/d52dba83525ef21f11840db0b691174ccf896a33))
+
 ## [0.8.0](https://github.com/asjer/rails-worktrees/compare/v0.7.4...v0.8.0) (2026-10-24)
 
 

data/README.md

@@ -55,10 +55,14 @@ bin/wt doctor                   # audit install/config drift and basic worktree
 bin/wt update --dry-run         # preview safe maintenance fixes
 bin/wt update                   # apply safe maintenance fixes for managed files
 bin/wt update --pi              # also add the pi-worktree hook in .pi/worktree.json
-bin/wt remove my-feature        # remove a worktree and delete its local branch
+bin/wt teardown --dry-run       # preview this worktree's Overmind and development/test databases
+bin/wt teardown                 # stop Overmind and drop worktree databases; keep checkout/branch
+bin/wt remove my-feature        # teardown a worktree, remove it and delete its local branch
 bin/wt delete my-feature        # alias for `bin/wt remove`
 bin/wt remove --force my-feature # also delete an unmerged local branch
 bin/wt prune                    # remove merged worktrees created by wt
+bin/wt help                     # same as --help; never creates a worktree
+bin/wt version                  # same as --version
 
 bin/ob                          # open http://localhost:$DEV_PORT/
 bin/ob contact                  # open http://localhost:$DEV_PORT/contact
@@ -70,8 +74,8 @@ bin/ob --print-url '?from=nav'  # print the resolved URL without opening a brows
 
 | Flag | Description |
 |------|-------------|
-| `-h`, `--help` | Show the help message |
-| `-v`, `--version` | Show the script version |
+| `-h`, `--help`, `help` | Show the help message |
+| `-v`, `--version`, `version` | Show the script version |
 | `--dry-run [name]` | Preview worktree creation or cleanup without changing anything |
 | `--skip-setup` | Create a worktree without running setup steps |
 | `--force` | Force branch deletion for `bin/wt remove` / `bin/wt delete` |
@@ -88,7 +92,7 @@ By default `bin/wt`:
 - auto-picks names from bundled `.txt` files when no explicit name is given
 - retires bundled names so they are not picked twice
 - bootstraps a worktree-local `.env` with deterministic `DEV_PORT` and `WORKTREE_DATABASE_SUFFIX` values
-- runs setup automatically after creation: credential linking, `bundle install`, `yarn install` when applicable, both `db:prepare` steps, test asset precompile, and a final `bin/rails assets:clobber`
+- runs setup automatically after creation: credential linking, `bundle install`, `yarn install` when applicable, the Playwright Chromium build for the pinned `playwright` package when it is missing, both `db:prepare` steps, test asset precompile, and a final `bin/rails assets:clobber`
 
 ```text
 workspace/
@@ -101,6 +105,32 @@ workspace/
 
 `WT_WORKSPACES_ROOT` or `config.workspace_root` overrides the destination root and uses the layout `<root>/<project>/<name>`.
 
+### Worktrees inside the repository
+
+Set `config.worktrees_dir` to keep worktrees inside the main checkout instead, in `<main checkout>/<worktrees_dir>/<name>`. This is the layout the [pi-worktree](https://www.npmjs.com/package/pi-worktree) extension uses, so `bin/wt` and Pi share one place for worktrees:
+
+```ruby
+Rails.application.config.x.rails_worktrees.tap do |config|
+  config.worktrees_dir = '.worktrees'
+  config.branch_prefix = 'worktree' # wt and pi-worktree both create worktree/<name>
+end
+```
+
+```text
+my-project/
+├── app/
+├── config/
+└── .worktrees/
+    ├── feature-auth/
+    └── bugfix-123/
+```
+
+- `worktrees_dir` must be a relative path inside the repository, such as `.worktrees` or `tmp/worktrees`. It always resolves against the main checkout, also when you run `bin/wt` from inside a worktree.
+- If `.gitignore` does not already ignore the directory, `bin/wt` adds `/.worktrees/` to `.git/info/exclude` when it creates a worktree, so `git status` in the main checkout stays clean. When it cannot write that file it prints a warning; add the directory to `.gitignore` yourself.
+- `bin/wt remove`, `bin/wt prune` and `bin/wt doctor` work in this layout too. `bin/wt doctor` warns when the directory is not ignored.
+- `worktrees_dir` cannot be combined with `workspace_root`. `WT_WORKSPACES_ROOT` still overrides both for a single run.
+- Tools that scan the main checkout's file tree (for example RuboCop, file watchers or Tailwind content globs) can pick up files from the worktrees. Exclude the directory there if needed.
+
 ### Setup command
 
 `bin/wt setup` reruns setup for the **current checkout**. Run it from inside a linked worktree created by `bin/wt`, a worktree created manually with `git worktree`, or a checkout prepared by another tool.
@@ -131,7 +161,8 @@ bin/wt setup
 
 `bin/wt` also supports cleanup commands for worktrees it manages:
 
-- `bin/wt remove <name>` — remove the named worktree and delete its local branch
+- `bin/wt teardown` — stop the current worktree's Overmind and drop its development/test databases, keeping the checkout and branch
+- `bin/wt remove <name>` — run the same teardown, remove the named worktree and delete its local branch
 - `bin/wt delete <name>` — alias for `bin/wt remove <name>`
 - `bin/wt prune` — remove merged worktrees created by `bin/wt` in bulk
 
@@ -141,7 +172,17 @@ bin/wt setup
 
 `bin/wt prune` only targets linked worktrees created by `bin/wt` whose local branches are already merged into `origin`'s default branch. It skips the main checkout, skips the checkout you're currently in, and asks for confirmation before deleting the batch.
 
-If you want to preview a single removal first, use `--dry-run` with `bin/wt remove`:
+### Teardown command
+
+Run `bin/wt teardown` **inside a linked worktree** (including manually created or Pi worktrees). It boots that app separately in test and development (so environment-specific files and database URLs are resolved correctly), checks **all** task-enabled development/test database configurations and Rails' protected-environment metadata, stops Overmind with `overmind quit --socket .overmind.sock` if that local socket exists, and drops only those validated databases through Rails' database tasks. Production databases and the checkout/branch are left alone. Multi-database configurations (primary, cache, queue, cable, etc.) are supported; replicas and configurations with `database_tasks: false` are not dropped.
+
+Teardown refuses the main checkout, a missing/blank `WORKTREE_DATABASE_SUFFIX`, and any database whose name does not contain that suffix. For SQLite, the suffix must be in the filename, not merely a parent directory. **All names are validated before Overmind or any database is touched.** A working app bundle for both environments and `bin/rails` are required; install missing gems or fix unsafe database configuration before retrying. Both environments are booted even for a dry-run, so application initializers still execute. Rails' production/environment-mismatch protection cannot be bypassed with `DISABLE_DATABASE_ENVIRONMENT_CHECK`. The resolved test configuration is passed privately to the development process; all safety checks complete before Overmind is stopped or any database is dropped.
+
+The worktree's `.env` may define a literal `WORKTREE_DATABASE_SUFFIX` (unquoted or single/double quoted, optionally with `export`). Teardown never generates a suffix. When run inside the worktree it can also use the current environment if `.env` does not define one. `remove` reads the **target's** `.env` and starts Rails with only the caller's OS/Ruby runtime variables, never its suffix, database URLs, application settings or bundle. Any other required application settings/credentials must therefore be loadable by the target app itself (for example with dotenv or Rails credentials). Ensure that target file contains the actual suffix used to create its databases.
+
+`bin/wt remove` / `delete` run this same teardown **before** deleting the worktree or branch. If validation, Overmind shutdown, or a database drop fails, removal aborts and keeps the checkout and branch. Database drops are not transactional: databases already dropped before a later failure cannot be restored by this command. If only the branch remains (the worktree directory is already gone), removal only deletes the branch. `prune` retains its existing Git-only behavior; run teardown on its candidates first if they have databases.
+
+Use `bin/wt teardown --dry-run` to list the local Overmind socket and exact development/test database names without stopping or dropping them. To preview both teardown and checkout/branch removal, use `--dry-run` with `bin/wt remove`:
 
 ```bash
 bin/wt remove --dry-run feature-auth
@@ -188,7 +229,7 @@ Both commands create or update `.pi/worktree.json`:
 }
 ```
 
-`.pi/worktree.json` is read by the [pi-worktree](https://www.npmjs.com/package/pi-worktree) npm extension (`pi install pi-worktree`), **not** by Pi core. Without that extension, the file has no effect. pi-worktree places worktrees in `.worktrees/` inside the repository by default, so add that directory to `.gitignore`.
+`.pi/worktree.json` is read by the [pi-worktree](https://www.npmjs.com/package/pi-worktree) npm extension (`pi install pi-worktree`), **not** by Pi core. Without that extension, the file has no effect. pi-worktree places worktrees in `.worktrees/` inside the repository by default. Set `config.worktrees_dir = '.worktrees'` and `config.branch_prefix = 'worktree'` to have `bin/wt` use the same directory and branch names; see [Worktrees inside the repository](#worktrees-inside-the-repository).
 
 `linkEnvFiles: false` matters. By default, pi-worktree symlinks the main checkout's gitignored `.env*` files into a new worktree before `postCreate` runs. `bin/wt setup` keeps existing `.env` values, so every Pi worktree would then reuse the main checkout's `DEV_PORT` and `WORKTREE_DATABASE_SUFFIX`, and setup would write through the symlink into the main checkout. With linking disabled, each worktree gets its own `.env` and database identity.
 
@@ -196,7 +237,19 @@ Existing configuration is merged, not replaced:
 
 - other keys (`dir`, `branchPrefix`, `preRemove`, …) and custom `postCreate` hooks are preserved; `bin/wt setup` is appended once and never duplicated
 - `linkEnvFiles` is only added when it is absent; an explicit `"linkEnvFiles": true`, invalid JSON, or a non-list `postCreate` is left untouched with a message explaining what to change by hand
-- no `preRemove` hook is added, and the worktree directory and branch prefix stay under your control
+- no `preRemove` hook is added automatically, and the worktree directory and branch prefix stay under your control
+
+To opt into environment cleanup when Pi's pi-worktree extension destroys a worktree, add `bin/wt teardown` to `preRemove` (preserve any existing hooks):
+
+```json
+{
+  "linkEnvFiles": false,
+  "postCreate": ["bin/wt setup"],
+  "preRemove": ["bin/wt teardown"]
+}
+```
+
+The extension runs `preRemove` from inside the worktree. Teardown only cleans the environment; the calling tool remains responsible for removing the checkout and branch. Keep `linkEnvFiles: false` so a worktree does not share the main checkout's `.env`. Preview the cleanup inside the worktree with `bin/wt teardown --dry-run` first.
 
 pi-worktree runs each `postCreate` step with a 120-second timeout. If a first `bundle install` or `db:prepare` takes longer, run `bin/wt setup` again inside the worktree.
 
@@ -247,6 +300,8 @@ New installs and repaired apps use a bash bootstrap wrapper that activates mise
 
 Worktree names must not contain `/` or whitespace, must not be `.` or `..`, and must be a valid Git ref component.
 
+These reserved words are commands, so `bin/wt <word>` never creates or reuses a worktree with that name and auto-picking skips them: `help`, `version`, `doctor`, `setup`, `update`, `prune`, `remove` and `delete`. `bin/wt help` and `bin/wt version` behave like `--help` and `--version`. An existing worktree with such a name (for example one created by `bin/wt help` in an older version) can still be cleaned up with `bin/wt remove help` or set up with `bin/wt setup ../<project>.worktrees/help`.
+
 ### Configuration
 
 The installer generates `config/initializers/rails_worktrees.rb` where you can override:
@@ -257,6 +312,7 @@ The initializer stays app-owned and gem-agnostic; `rails-worktrees` reads those
 |--------|---------|-------------|
 | `bootstrap_env` | `true` | Write `.env` when creating a worktree |
 | `workspace_root` | `nil` | Override the destination root (sibling layout when `nil`) |
+| `worktrees_dir` | `nil` | Create worktrees inside the main checkout, e.g. `'.worktrees'`; see [Worktrees inside the repository](#worktrees-inside-the-repository) |
 | `dev_port_range` | `3000..3999` | Port range for deterministic `DEV_PORT` allocation |
 | `branch_prefix` | `🚂` | Prefix for worktree branch names |
 | `name_sources_path` | bundled `names/` | Directory containing `.txt` name lists |

data/lib/generators/rails/worktrees/templates/bin/wt

@@ -77,14 +77,14 @@ exec ruby /dev/fd/3 "$@" 3<<'RUBY'
 def rails_worktrees_bootstrap_safe_invocation?(argv)
   args = argv.map(&:to_s)
   return true if args.empty?
-  return true if %w[-h --help -v --version].include?(args.first)
+  return true if %w[-h --help help -v --version version].include?(args.first)
   return true if %w[--env --print-env].include?(args.first)
 
   command_args = args.reject { |arg| %w[--dry-run --skip-setup --pi --env --print-env].include?(arg) }
   command = command_args.first
 
   return true if %w[setup doctor update].include?(command)
-  return false if %w[remove delete prune].include?(command)
+  return false if %w[remove delete prune teardown].include?(command)
 
   command_args.length <= 1
 end

data/lib/generators/rails/worktrees/templates/rails_worktrees.rb.tt

@@ -5,6 +5,13 @@ Rails.application.config.x.rails_worktrees.tap do |config|
   # By default, worktrees go in a sibling "<project>.worktrees" directory.
   # Uncomment to override with a custom parent directory that uses <root>/<project>/<name>.
   # config.workspace_root = File.expand_path('~/worktrees')
+  #
+  # Or keep worktrees inside this checkout in <app>/.worktrees/<name>, like Pi's pi-worktree
+  # extension. wt adds the directory to .git/info/exclude unless .gitignore already covers it.
+  # Combine with branch_prefix 'worktree' so wt and Pi share worktree/<name> branch names.
+  # Cannot be combined with workspace_root.
+  # config.worktrees_dir = '.worktrees'
+  # config.branch_prefix = 'worktree'
 <% end -%>
   # config.bootstrap_env = false
   # config.dev_port_range = 3000..3999
@@ -21,6 +28,7 @@ Rails.application.config.x.rails_worktrees.tap do |config|
   # config.post_create_command = nil    # nil = built-in steps; false = skip all; 'script/worktree-setup' = custom command
   # config.run_bundle_install = true
   # config.run_yarn_install = true      # auto-skipped when yarn.lock is absent
+  # config.run_playwright_install = true # installs Playwright Chromium when package.json uses playwright
   # config.run_db_prepare = true
   # config.run_test_db_prepare = true
   # config.run_test_assets_precompile = true

data/lib/rails/worktrees/cli.rb

@@ -2,7 +2,9 @@ module Rails
   module Worktrees
     # Shell entrypoint for the wt executable.
     class CLI
-      LOADER_OPTIONAL_COMMANDS = %w[doctor update -h --help -v --version].freeze
+      LOADER_OPTIONAL_COMMANDS = %w[doctor update -h --help help -v --version version].freeze
+      # Commands that use project configuration when it loads, but must keep working when it does not.
+      LOADER_BEST_EFFORT_COMMANDS = %w[doctor].freeze
       LOADER_IGNORED_FLAGS = %w[--dry-run --force --skip-setup --pi].freeze
       SETUP_SUBCOMMAND = 'setup'.freeze
 
@@ -20,7 +22,11 @@ module Rails
 
       def start
         configuration = ::Rails::Worktrees.configuration
-        load_project_configuration(configuration) if should_load_project_configuration?
+        if should_load_project_configuration?
+          load_project_configuration(configuration)
+        elsif best_effort_configuration_command?
+          load_project_configuration_best_effort(configuration)
+        end
         command_for(configuration).run
       rescue ::Rails::Worktrees::Error => e
         @io.fetch(:stderr).puts("Error: #{e.message}")
@@ -35,6 +41,17 @@ module Rails
         raise ::Rails::Worktrees::Error, "Failed to load worktrees configuration: #{e.class}: #{e.message}"
       end
 
+      # A broken initializer must not block recovery; wt doctor then reports with default settings.
+      def load_project_configuration_best_effort(configuration)
+        load_project_configuration(configuration)
+      rescue ::Rails::Worktrees::Error
+        configuration
+      end
+
+      def best_effort_configuration_command?
+        LOADER_BEST_EFFORT_COMMANDS.include?(argv_without_flags.first)
+      end
+
       def configuration_root
         return expand_setup_target_path if explicit_setup_path_target?
 

data/lib/rails/worktrees/command/in_repo_worktrees.rb

@@ -0,0 +1,85 @@
+require 'fileutils'
+
+module Rails
+  module Worktrees
+    class Command
+      # Keeps an in-repo worktrees_dir out of the main checkout's untracked files.
+      module InRepoWorktrees
+        private
+
+        def in_repo_layout?(workspaces) = workspaces[:layout] == :in_repo
+
+        def ensure_worktrees_dir_ignored(context)
+          workspaces = context[:workspaces]
+          return unless in_repo_layout?(workspaces)
+          return if worktrees_dir_ignored?(context[:primary_root], workspaces)
+
+          entry = worktrees_dir_exclude_entry(workspaces)
+          exclude_path = info_exclude_path(context[:primary_root])
+          return info("Would add '#{entry}' to #{exclude_path}") if dry_run?
+
+          append_exclude_entry(exclude_path, entry)
+        end
+
+        def worktrees_dir_ignored?(primary_root, workspaces)
+          git_success?('-C', primary_root, 'check-ignore', '-q', "#{workspaces[:relative_dir]}/")
+        end
+
+        # Escapes gitignore metacharacters so the entry matches only the literal directory.
+        def worktrees_dir_exclude_entry(workspaces)
+          escaped = workspaces[:relative_dir]
+                    .gsub(/[\\*?\[\]]/) { |char| "\\#{char}" }
+                    .sub(/ +\z/) { |spaces| spaces.gsub(' ', '\ ') }
+          "/#{escaped}/"
+        end
+
+        def info_exclude_path(primary_root)
+          git_path = git_capture('-C', primary_root, 'rev-parse', '--git-path', 'info/exclude').strip
+          expand_git_path(git_path, base_dir: primary_root)
+        end
+
+        def append_exclude_entry(exclude_path, entry)
+          FileUtils.mkdir_p(File.dirname(exclude_path))
+          separator = missing_trailing_newline?(exclude_path) ? "\n" : ''
+          File.open(exclude_path, 'a') { |file| file.write("#{separator}#{entry}\n") }
+          info("Added '#{entry}' to #{exclude_path} so the main checkout ignores in-repo worktrees")
+        rescue SystemCallError => e
+          warning(
+            "Could not update #{exclude_path} (#{e.class}); add '#{entry}' to .gitignore " \
+            'so the main checkout does not show the worktrees as untracked files.'
+          )
+        end
+
+        def missing_trailing_newline?(path)
+          File.file?(path) && !File.empty?(path) && !File.read(path).end_with?("\n")
+        end
+
+        def in_repo_worktrees_doctor_check(repository)
+          workspaces = repository[:workspaces]
+          return unless in_repo_layout?(workspaces)
+
+          if worktrees_dir_ignored?(repository[:primary_root], workspaces)
+            ignored_worktrees_dir_check(workspaces)
+          else
+            unignored_worktrees_dir_check(workspaces)
+          end
+        end
+
+        def ignored_worktrees_dir_check(workspaces)
+          doctor_check(category: :worktree, status: :ok,
+                       headline: "In-repo worktrees directory #{workspaces[:root]} is ignored by Git.")
+        end
+
+        def unignored_worktrees_dir_check(workspaces)
+          doctor_check(
+            category: :worktree,
+            status: :warning,
+            headline: "In-repo worktrees directory #{workspaces[:root]} is not ignored by Git.",
+            messages: ["Add '#{worktrees_dir_exclude_entry(workspaces)}' to .gitignore, " \
+                       'or create a worktree with wt to add it to .git/info/exclude.']
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rails/worktrees/command/name_picking.rb

@@ -45,7 +45,8 @@ module Rails
 
         def list_available_names(source_file, project_name, workspaces)
           source_names(source_file).select do |candidate|
-            valid_auto_name?(candidate) && available_for_auto_pick?(candidate, project_name, workspaces)
+            !RESERVED_WORDS.include?(candidate) && valid_auto_name?(candidate) &&
+              available_for_auto_pick?(candidate, project_name, workspaces)
           end
         end
 

data/lib/rails/worktrees/command/output.rb

@@ -8,10 +8,10 @@ module Rails
 
         def handle_meta_command
           case @argv.first
-          when '-h', '--help'
+          when '-h', '--help', 'help'
             @stdout.print(usage)
             0
-          when '-v', '--version'
+          when '-v', '--version', 'version'
             @stdout.puts("wt #{Rails::Worktrees::VERSION}")
             0
           when '--env', '--print-env'
@@ -30,19 +30,21 @@ module Rails
             Create and clean up Git worktrees for the current repository.
 
             Usage: wt [worktree-name]
+                   wt help | wt version
                    wt [--skip-setup] [worktree-name]
                    wt --dry-run [worktree-name]
                    wt --print-env <worktree-name>
                    wt doctor
                    wt setup [--dry-run] [path|name]
                    wt update [--dry-run] [--pi]
+                   wt teardown [--dry-run]
                    wt remove [--dry-run] [--force] <worktree-name>
                    wt delete [--dry-run] [--force] <worktree-name>
                    wt prune [--dry-run]
 
             Options:
-              -h, --help                  Show this help message
-              -v, --version               Show the script version
+              -h, --help, help            Show this help message
+              -v, --version, version      Show the script version
               --dry-run [name]            Preview worktree creation or cleanup without changing anything
               --skip-setup               Create the worktree without running setup steps
               --force                     Delete an unmerged local branch with wt remove/delete
@@ -60,6 +62,8 @@ module Rails
               wt setup my-feature
               wt setup ../my-project.worktrees/my-feature
               wt update --dry-run
+              wt teardown --dry-run
+              wt teardown
               wt remove my-feature
               wt remove --force my-feature
               wt prune
@@ -67,6 +71,8 @@ module Rails
             How it works:
               - by default creates worktrees beside the repo in ../<project>.worktrees/<name>
               - when workspace_root or WT_WORKSPACES_ROOT is set, creates worktrees in <root>/<project>/<name>
+              - when worktrees_dir is set (for example '.worktrees'), creates worktrees inside the main checkout in <repo>/<worktrees_dir>/<name>
+              - reserved words are commands, never new worktree names: #{RESERVED_WORDS.join(', ')}
               - always uses the branch name #{@configuration.branch_prefix}/<name>
               - bases new branches on the repository's origin default branch
               - by default wt <name> both creates the worktree and runs setup automatically
@@ -74,6 +80,8 @@ module Rails
               - wt doctor audits install/config drift plus basic worktree health without changing files
               - wt update applies safe file-based fixes for managed installer artifacts and config hints
               - wt update --pi also writes .pi/worktree.json for the pi-worktree extension (not Pi core)
+              - wt teardown stops local Overmind and drops suffix-validated development/test databases, keeping the checkout
+              - wt remove/delete run teardown before removing the checkout and local branch
               - wt remove/delete can run from the main checkout or any sibling worktree, but never remove the worktree you're currently in
               - wt prune removes merged worktrees created by wt while skipping the main checkout and the checkout you're in
               - auto-discovers bundled *.txt files from #{@configuration.name_sources_path}

data/lib/rails/worktrees/command/workspace_paths.rb

@@ -1,8 +1,11 @@
 module Rails
   module Worktrees
     class Command
-      # Resolves the default and explicit workspace path layouts.
+      # Resolves the sibling (default), workspace_root and in-repo worktrees_dir path layouts.
       module WorkspacePaths
+        INVALID_WORKTREES_DIR_MESSAGE =
+          "worktrees_dir must be a relative path inside the repository, like '.worktrees' (got %p).".freeze
+
         private
 
         def resolve_repository_context
@@ -41,9 +44,16 @@ module Rails
 
         def resolve_workspaces(repo_root, project_name)
           explicit_root = configured_workspaces_root
-          return { root: explicit_root, uses_default_root: false } if explicit_root
+          return { root: explicit_root, layout: :workspace_root, uses_default_root: false } if explicit_root
+
+          in_repo_dir = configured_worktrees_dir
+          if in_repo_dir
+            return { root: File.join(repo_root, in_repo_dir), layout: :in_repo, relative_dir: in_repo_dir,
+                     uses_default_root: false }
+          end
 
-          { root: File.join(File.dirname(repo_root), "#{project_name}.worktrees"), uses_default_root: true }
+          { root: File.join(File.dirname(repo_root), "#{project_name}.worktrees"), layout: :sibling,
+            uses_default_root: true }
         end
 
         def configured_workspaces_root
@@ -51,16 +61,37 @@ module Rails
           return expand_home(env_root) if present_path?(env_root)
 
           config_root = @configuration.workspace_root
-          return expand_home(config_root) if present_path?(config_root)
+          return unless present_path?(config_root)
+
+          if present_path?(@configuration.worktrees_dir)
+            raise Error, 'Set either workspace_root or worktrees_dir, not both.'
+          end
+
+          expand_home(config_root)
+        end
+
+        def configured_worktrees_dir
+          value = @configuration.worktrees_dir
+          return unless present_path?(value)
 
-          nil
+          normalized = Pathname(value.to_s).cleanpath
+          raise Error, format(INVALID_WORKTREES_DIR_MESSAGE, value) unless valid_worktrees_dir?(normalized)
+
+          normalized.to_s
+        end
+
+        def valid_worktrees_dir?(path)
+          first_component = path.each_filename.first
+
+          path.relative? && !path.to_s.start_with?('~') &&
+            !path.each_filename.include?('..') && !['.', '.git'].include?(first_component)
         end
 
         def target_dir_for(project_name, worktree_name, workspaces)
-          if workspaces[:uses_default_root]
-            File.join(workspaces[:root], worktree_name)
-          else
+          if workspaces[:layout] == :workspace_root
             File.join(workspaces[:root], project_name, worktree_name)
+          else
+            File.join(workspaces[:root], worktree_name)
           end
         end
 
@@ -85,7 +116,7 @@ module Rails
         end
 
         def present_path?(path)
-          !path.nil? && !path.empty?
+          !path.nil? && !path.to_s.empty?
         end
 
         def expand_home(path)

data/lib/rails/worktrees/command.rb

@@ -1,6 +1,7 @@
 require 'fileutils'
 require_relative 'command/environment_support'
 require_relative 'command/git_operations'
+require_relative 'command/in_repo_worktrees'
 require_relative 'command/name_picking'
 require_relative 'command/output'
 require_relative 'command/post_create_support'
@@ -15,10 +16,13 @@ module Rails
       DOCTOR_SUBCOMMAND = 'doctor'.freeze
       SETUP_SUBCOMMAND = 'setup'.freeze
       UPDATE_SUBCOMMAND = 'update'.freeze
-      PI_FLAG_EXEMPT_META_COMMANDS = %w[-h --help -v --version].freeze
+      PI_FLAG_EXEMPT_META_COMMANDS = %w[-h --help help -v --version version].freeze
+      # Command words that wt never treats as a worktree name.
+      RESERVED_WORDS = %w[help version doctor setup update teardown prune remove delete].freeze
 
       include GitOperations
       include EnvironmentSupport
+      include InRepoWorktrees
       include NamePicking
       include Output
       include PostCreateSupport
@@ -115,6 +119,7 @@ module Rails
         when SETUP_SUBCOMMAND then -> { execute_setup_command }
         when UPDATE_SUBCOMMAND then -> { execute_update_command }
         when 'prune' then -> { execute_prune_command }
+        when 'teardown' then -> { execute_teardown_command }
         else
           -> { execute_remove_command } if remove_subcommand?
         end
@@ -135,11 +140,16 @@ module Rails
           confirm_and_remove_target(context[:target_dir])
         end
 
-        prepare_target_parent(context[:target_dir])
+        prepare_worktree_location(context)
         attach_or_create_worktree(context)
         finish(context)
       end
 
+      def prepare_worktree_location(context)
+        ensure_worktrees_dir_ignored(context)
+        prepare_target_parent(context[:target_dir])
+      end
+
       def execute_setup_command
         validate_setup_args!
         announce_dry_run if dry_run?
@@ -150,6 +160,25 @@ module Rails
         complete_setup_flow(context, success_message: 'Setup complete')
       end
 
+      def execute_teardown_command
+        raise Error, 'Usage: wt teardown [--dry-run]' unless @argv.length == 1 && !force? && !skip_setup?
+
+        require_git_repo
+        repository = resolve_repository_context
+        if repository[:current_root] == repository[:primary_root]
+          raise Error, 'Cannot teardown the main checkout. Run wt teardown inside a linked worktree.'
+        end
+
+        teardown_worktree(repository[:current_root], use_current_env: true)
+        success(dry_run? ? 'Dry run complete' : 'Teardown complete')
+        0
+      end
+
+      def teardown_worktree(target_dir, use_current_env: false)
+        TeardownRunner.new(target_dir: target_dir, env: @env, io: { stdout: @stdout },
+                           use_current_env: use_current_env).call(dry_run: dry_run?)
+      end
+
       def execute_remove_command
         require_git_repo
         announce_dry_run if dry_run?
@@ -159,6 +188,7 @@ module Rails
         removal_status = removal_status_for(context)
 
         ensure_removable!(context, **removal_status)
+        teardown_worktree(context[:target_dir]) if removal_status[:worktree_exists]
         return complete_remove_dry_run(context, **removal_status) if dry_run?
 
         perform_remove(context, **removal_status)
@@ -212,8 +242,8 @@ module Rails
           return 1
         end
 
-        repository = resolve_repository_context
-        checks = project_maintenance_report(repository[:current_root]).checks + doctor_worktree_checks(repository)
+        current_root = canonical_path(git_capture('rev-parse', '--show-toplevel').strip)
+        checks = project_maintenance_report(current_root).checks + doctor_worktree_checks(current_root)
         print_doctor_report(checks)
 
         checks.any? { |check| check.fixable? || check.warning? } ? 1 : 0
@@ -653,16 +683,23 @@ module Rails
         ::Rails::Worktrees::ProjectMaintenance.new(root: root, pi_worktree: pi?).call
       end
 
-      def doctor_worktree_checks(repository)
+      def doctor_worktree_checks(current_root)
         [
           doctor_check(
             category: :git,
             status: :ok,
-            headline: "Git repository detected at #{repository[:current_root]}."
+            headline: "Git repository detected at #{current_root}."
           ),
           default_branch_doctor_check,
-          stale_worktree_doctor_check
-        ]
+          stale_worktree_doctor_check,
+          worktree_layout_doctor_check
+        ].compact
+      end
+
+      def worktree_layout_doctor_check
+        in_repo_worktrees_doctor_check(resolve_repository_context)
+      rescue Error => e
+        doctor_check(category: :worktree, status: :warning, headline: e.message)
       end
 
       def default_branch_doctor_check

data/lib/rails/worktrees/configuration.rb

@@ -5,6 +5,7 @@ module Rails
       CONFIGURABLE_ATTRIBUTES = %i[
         bootstrap_env
         workspace_root
+        worktrees_dir
         dev_port_range
         branch_prefix
         name_sources_path
@@ -13,6 +14,7 @@ module Rails
         post_create_command
         run_bundle_install
         run_yarn_install
+        run_playwright_install
         run_db_prepare
         run_test_db_prepare
         run_test_assets_precompile
@@ -33,10 +35,10 @@ module Rails
       DEFAULT_WORKTREE_DATABASE_SUFFIX_MAX_LENGTH = 18
 
       attr_accessor :bootstrap_env, :branch_prefix, :dev_port_range, :legacy_used_names_files,
-                    :name_sources_path, :used_names_file, :workspace_root,
+                    :name_sources_path, :used_names_file, :workspace_root, :worktrees_dir,
                     :worktree_database_suffix_max_length,
                     :post_create_command,
-                    :run_bundle_install, :run_yarn_install,
+                    :run_bundle_install, :run_yarn_install, :run_playwright_install,
                     :run_db_prepare, :run_test_db_prepare, :run_test_assets_precompile,
                     :link_credential_keys, :link_test_credential_key, :link_production_credential_key
 
@@ -50,6 +52,7 @@ module Rails
       def assign_core_defaults
         @bootstrap_env = DEFAULT_BOOTSTRAP_ENV
         @workspace_root = nil
+        @worktrees_dir = nil
         @branch_prefix = DEFAULT_BRANCH_PREFIX
         @dev_port_range = DEFAULT_DEV_PORT_RANGE
         @name_sources_path = DEFAULT_NAME_SOURCES_PATH
@@ -62,6 +65,7 @@ module Rails
         @post_create_command = nil
         @run_bundle_install = true
         @run_yarn_install = true
+        @run_playwright_install = true
         @run_db_prepare = true
         @run_test_db_prepare = true
         @run_test_assets_precompile = true

data/lib/rails/worktrees/playwright_browser_check.rb

@@ -0,0 +1,56 @@
+require 'json'
+require 'open3'
+
+module Rails
+  module Worktrees
+    # Decides whether a worktree needs the Playwright Chromium build that matches
+    # the playwright package pinned in its package.json.
+    class PlaywrightBrowserCheck
+      PACKAGES = %w[playwright @playwright/test].freeze
+      DEPENDENCY_SECTIONS = %w[dependencies devDependencies].freeze
+      CLI_PATH = 'node_modules/.bin/playwright'.freeze
+      BROWSER = 'chromium'.freeze
+      INSTALL_LOCATION = /^\s*Install location:\s*(.+?)\s*$/
+      # Playwright writes this marker once a browser download has been fully extracted.
+      INSTALLATION_MARKER = 'INSTALLATION_COMPLETE'.freeze
+
+      def initialize(target_dir:, env:)
+        @target_dir = target_dir
+        @env = env
+      end
+
+      def applicable?
+        package = JSON.parse(File.read(File.join(@target_dir, 'package.json')))
+        DEPENDENCY_SECTIONS.any? do |section|
+          dependencies = package[section]
+          dependencies.is_a?(Hash) && PACKAGES.any? { |name| dependencies.key?(name) }
+        end
+      rescue Errno::ENOENT, JSON::ParserError
+        false
+      end
+
+      def cli_present?
+        File.exist?(File.join(@target_dir, CLI_PATH))
+      end
+
+      # Returns false whenever the installed state cannot be proven.
+      def installed?
+        locations = install_locations
+        !locations.empty? && locations.all? { |location| File.file?(File.join(location, INSTALLATION_MARKER)) }
+      end
+
+      private
+
+      def install_locations
+        return [] unless cli_present?
+
+        output, status = Open3.capture2e(@env, CLI_PATH, 'install', '--dry-run', BROWSER, chdir: @target_dir)
+        return [] unless status.success?
+
+        output.scan(INSTALL_LOCATION).flatten
+      rescue SystemCallError
+        []
+      end
+    end
+  end
+end

data/lib/rails/worktrees/post_create_runner.rb

@@ -3,7 +3,7 @@ require 'open3'
 module Rails
   module Worktrees
     # Runs post-create setup steps in a newly created worktree.
-    # Steps run in order: credential linking, bundle install, yarn install,
+    # Steps run in order: credential linking, bundle install, yarn install, Playwright Chromium install,
     # db:prepare (development), db:prepare (test), assets:precompile (test), assets:clobber.
     # rubocop:disable Metrics/ClassLength
     class PostCreateRunner
@@ -12,6 +12,8 @@ module Rails
           header: '📦 Installing gems...' },
         { id: :yarn, argv: %w[yarn install],
           header: '🧶 Installing JS dependencies...' },
+        { id: :playwright, argv: [PlaywrightBrowserCheck::CLI_PATH, 'install', PlaywrightBrowserCheck::BROWSER],
+          header: '🎭 Installing Playwright Chromium...' },
         { id: :db_prepare, argv: %w[bin/rails db:prepare],
           header: '🗄️  Preparing development database...', env: { 'RAILS_ENV' => 'development' } },
         { id: :test_db_prepare, argv: %w[bin/rails db:prepare],
@@ -25,6 +27,7 @@ module Rails
       STEP_CONFIG = {
         bundle: :run_bundle_install,
         yarn: :run_yarn_install,
+        playwright: :run_playwright_install,
         db_prepare: :run_db_prepare,
         test_db_prepare: :run_test_db_prepare,
         test_assets_precompile: :run_test_assets_precompile,
@@ -78,15 +81,52 @@ module Rails
         STEPS.each do |step|
           config_attr = STEP_CONFIG[step[:id]]
           next unless @configuration.public_send(config_attr)
-          next if step[:id] == :yarn && !yarn_lock_present?
+          next unless step_applicable?(step)
 
-          result = run_step(step, dry_run: dry_run)
+          result = run_built_in_step(step, dry_run: dry_run)
           return result unless result.zero?
         end
 
         0
       end
 
+      def step_applicable?(step)
+        case step[:id]
+        when :yarn then yarn_lock_present?
+        when :playwright then yarn_lock_present? && playwright_browser_check.applicable?
+        else true
+        end
+      end
+
+      def run_built_in_step(step, dry_run:)
+        return run_playwright_step(step, dry_run: dry_run) if step[:id] == :playwright
+
+        run_step(step, dry_run: dry_run)
+      end
+
+      # Always runs the real installer: it skips cached downloads itself and registers this
+      # worktree in the shared browser cache, so a later cleanup keeps its browsers.
+      def run_playwright_step(step, dry_run:)
+        check = playwright_browser_check
+        return preview_playwright_step(step, check) if dry_run
+
+        unless check.cli_present?
+          info("⚠️  Skipping Playwright Chromium: #{PlaywrightBrowserCheck::CLI_PATH} was not found.")
+          return 0
+        end
+
+        run_step(step, dry_run: false)
+      end
+
+      def preview_playwright_step(step, check)
+        info('🎭 Playwright Chromium is already installed; no download needed.') if check.installed?
+        run_step(step, dry_run: true)
+      end
+
+      def playwright_browser_check
+        PlaywrightBrowserCheck.new(target_dir: @target_dir, env: runtime_env)
+      end
+
       def run_credential_linking(dry_run:)
         # Missing peer key files are intentionally best-effort and should not abort
         # worktree setup; the linker reports those cases in its messages while real
@@ -158,7 +198,8 @@ module Rails
                        'BUNDLE_GEMFILE', 'BUNDLE_PATH', 'GEM_HOME', 'GEM_PATH',
                        'RUBY_VERSION', 'RAILS_ENV', 'NODE_ENV',
                        'XDG_STATE_HOME', 'XDG_DATA_HOME', 'XDG_CONFIG_HOME',
-                       'DEV_PORT', 'WORKTREE_DATABASE_SUFFIX')
+                       'DEV_PORT', 'WORKTREE_DATABASE_SUFFIX',
+                       'PLAYWRIGHT_BROWSERS_PATH')
       end
 
       attr_reader :runtime_env

data/lib/rails/worktrees/teardown_runner.rb

@@ -0,0 +1,84 @@
+require 'open3'
+require 'tempfile'
+
+module Rails
+  module Worktrees
+    # Runs teardown in the target app, without borrowing the caller's suffix or bundle.
+    class TeardownRunner
+      RUNTIME_KEYS = %w[PATH HOME USER LOGNAME SHELL LANG LANGUAGE LC_ALL LC_CTYPE TMPDIR TMP TEMP
+                        GEM_HOME GEM_PATH LD_LIBRARY_PATH SSL_CERT_FILE SSL_CERT_DIR].freeze
+      RUBY_LOADER_KEYS = %w[RUBYOPT RUBYLIB].freeze
+      SUFFIX_KEY = 'WORKTREE_DATABASE_SUFFIX'.freeze
+      SCRIPT = File.expand_path('teardown_script.rb', __dir__).freeze
+
+      def initialize(target_dir:, env:, io:, use_current_env: false)
+        @target_dir = target_dir
+        @env = env.to_h
+        @stdout = io.fetch(:stdout)
+        @use_current_env = use_current_env
+      end
+
+      def call(dry_run: false)
+        env = runtime_env
+        validate_environment!(env)
+        Tempfile.create('rails-worktrees-teardown') do |plan|
+          run_teardown(env, plan.path, dry_run: dry_run)
+        end
+      rescue SystemCallError => e
+        raise Error, "Could not start teardown: #{e.message}"
+      end
+
+      private
+
+      def run_teardown(env, plan_path, dry_run:)
+        run(env.merge('RAILS_ENV' => 'test', 'RACK_ENV' => 'test'),
+            [rails_bin, 'runner', SCRIPT, '--export-test-configs', plan_path])
+        argv = [rails_bin, 'runner', SCRIPT, '--test-configs', plan_path]
+        argv << '--dry-run' if dry_run
+        run(env, argv)
+      end
+
+      def validate_environment!(env)
+        if env[SUFFIX_KEY].to_s.strip.empty?
+          raise Error, 'WORKTREE_DATABASE_SUFFIX must not be empty; refusing teardown.'
+        end
+        raise Error, "Expected #{@target_dir}/bin/rails for teardown." unless File.file?(rails_bin)
+      end
+
+      def run(env, argv)
+        Open3.popen2e(env, *argv, chdir: @target_dir, unsetenv_others: true) do |stdin, output, wait|
+          stdin.close
+          output.each_line { |line| @stdout.print(line) }
+          raise Error, 'Teardown failed; worktree and branch were kept.' unless wait.value.success?
+        end
+      end
+
+      def rails_bin = File.join(@target_dir, 'bin', 'rails')
+
+      def runtime_env
+        source = @use_current_env ? @env : @env.slice(*RUNTIME_KEYS)
+        env = source.reject { |key, _| key.start_with?('BUNDLE_', 'GIT_') || RUBY_LOADER_KEYS.include?(key) }
+        suffix = file_suffix
+        env[SUFFIX_KEY] = suffix unless suffix.nil?
+        env.merge('RAILS_ENV' => 'development', 'RACK_ENV' => 'development',
+                  'BUNDLE_GEMFILE' => File.join(@target_dir, 'Gemfile'))
+      end
+
+      def file_suffix
+        path = File.join(@target_dir, '.env')
+        return unless File.file?(path)
+
+        line = File.readlines(path, chomp: true).reverse.find do |entry|
+          entry.match?(/\A\s*(?:export\s+)?WORKTREE_DATABASE_SUFFIX\s*=/)
+        end
+        return unless line
+
+        value = line.split('=', 2).last.strip
+        match = value.match(/\A(?:'([^']*)'|"([^"]*)"|([^\s#'"$`]*))\s*(?:#.*)?\z/)
+        raise Error, 'Cannot safely read WORKTREE_DATABASE_SUFFIX from .env; use a literal value.' unless match
+
+        match.captures.compact.first
+      end
+    end
+  end
+end

data/lib/rails/worktrees/teardown_script.rb

@@ -0,0 +1,115 @@
+require 'json'
+
+# Executed by the target app's Rails runner, first in test, then in development.
+module Rails
+  module Worktrees
+    # Validates the complete Rails database plan before applying any destructive effects.
+    class DatabaseTeardown
+      class SafetyError < StandardError; end
+
+      def call(test_plan:, export: false, dry_run: false)
+        suffix = ENV.fetch('WORKTREE_DATABASE_SUFFIX', '')
+        raise SafetyError, 'WORKTREE_DATABASE_SUFFIX must not be empty; refusing teardown.' if suffix.strip.empty?
+
+        return export_test_configs(test_plan, suffix) if export
+
+        development = database_configs('development')
+        databases = development + test_configs(test_plan, suffix)
+        validate_databases!(databases, suffix)
+        check_protection!(development)
+        stop_overmind(dry_run: dry_run)
+        drop_databases(databases, dry_run: dry_run)
+      end
+
+      private
+
+      def database_configs(environment)
+        unless defined?(ActiveRecord::Base)
+          raise SafetyError, 'ActiveRecord is required to inspect development/test databases.'
+        end
+
+        configs = ActiveRecord::Base.configurations.configs_for(env_name: environment)
+        raise SafetyError, "No database configurations found for #{environment}; refusing teardown." if configs.empty?
+
+        configs
+      end
+
+      def export_test_configs(path, suffix)
+        configs = database_configs('test')
+        validate_databases!(configs, suffix)
+        check_protection!(configs)
+        File.write(path, JSON.generate('suffix' => suffix, 'configs' => config_hash(configs)))
+      end
+
+      def test_configs(path, suffix)
+        plan = JSON.parse(File.read(path))
+        if plan['suffix'] != suffix
+          raise SafetyError,
+                'Test environment changed WORKTREE_DATABASE_SUFFIX; refusing teardown.'
+        end
+
+        ActiveRecord::DatabaseConfigurations.new('test' => plan.fetch('configs')).configs_for(env_name: 'test')
+      end
+
+      def config_hash(configs)
+        configs.to_h { |config| [config.name, config.configuration_hash] }
+      end
+
+      def check_protection!(databases)
+        original = ActiveRecord::Base.configurations
+        existing = existing_databases(databases)
+        # Keep the resolved objects: rebuilding hashes would reapply environment URLs to explicit YAML URLs.
+        ActiveRecord::Base.configurations = existing
+        ENV.delete('DISABLE_DATABASE_ENVIRONMENT_CHECK')
+        existing.map(&:env_name).uniq.each do |environment|
+          ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!(environment)
+        end
+      ensure
+        ActiveRecord::Base.configurations = original if original
+      end
+
+      def existing_databases(databases)
+        # SQLite opens would create absent files even in a dry-run. Absent files have no protected metadata.
+        databases.reject { |config| config.adapter == 'sqlite3' && !File.exist?(config.database) }
+      end
+
+      def validate_databases!(databases, suffix)
+        databases.each do |config|
+          # A suffix in a SQLite directory does not protect an unsuffixed database file.
+          next if File.basename(config.database.to_s).include?(suffix)
+
+          raise SafetyError,
+                "Database '#{config.database}' (#{config.env_name}/#{config.name}) does not contain " \
+                "WORKTREE_DATABASE_SUFFIX '#{suffix}'; refusing teardown."
+        end
+      end
+
+      def drop_databases(databases, dry_run:)
+        databases.each do |config|
+          puts "#{dry_run ? 'Would drop' : 'Dropping'} database '#{config.database}' " \
+               "(#{config.env_name}/#{config.name})"
+          ActiveRecord::Tasks::DatabaseTasks.drop(config) unless dry_run
+        end
+      end
+
+      def stop_overmind(dry_run:)
+        return unless File.exist?('.overmind.sock')
+
+        puts "#{dry_run ? 'Would stop' : 'Stopping'} Overmind at #{File.expand_path('.overmind.sock')}"
+        return if dry_run
+        return if system('overmind', 'quit', '--socket', '.overmind.sock')
+
+        raise SafetyError, 'Could not stop Overmind; databases were kept.'
+      end
+    end
+  end
+end
+
+begin
+  export = ARGV.first == '--export-test-configs'
+  Rails::Worktrees::DatabaseTeardown.new.call(test_plan: ARGV.fetch(1), export: export,
+                                              dry_run: ARGV.include?('--dry-run'))
+rescue StandardError => e
+  warn "Teardown failed: #{e.message}"
+  exit 1
+end

data/lib/rails/worktrees/version.rb

@@ -1,5 +1,5 @@
 module Rails
   module Worktrees
-    VERSION = '0.8.0'.freeze
+    VERSION = '0.9.0'.freeze
   end
 end

data/lib/rails/worktrees.rb

@@ -6,7 +6,9 @@ require_relative 'worktrees/application_configuration'
 require_relative 'worktrees/mise_environment'
 require_relative 'worktrees/env_bootstrapper'
 require_relative 'worktrees/credential_key_linker'
+require_relative 'worktrees/playwright_browser_check'
 require_relative 'worktrees/post_create_runner'
+require_relative 'worktrees/teardown_runner'
 require_relative 'worktrees/command'
 require_relative 'worktrees/cli'
 require_relative 'worktrees/browser_command'

data/sig/rails/worktrees.rbs

@@ -8,6 +8,7 @@ module Rails
     class Configuration
       attr_accessor bootstrap_env: bool
       attr_accessor workspace_root: String?
+      attr_accessor worktrees_dir: String?
       attr_accessor branch_prefix: String
       attr_accessor dev_port_range: ::Range[Integer]
       attr_accessor name_sources_path: String

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-worktrees
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Asjer Querido
@@ -61,6 +61,7 @@ files:
 - lib/rails/worktrees/command.rb
 - lib/rails/worktrees/command/environment_support.rb
 - lib/rails/worktrees/command/git_operations.rb
+- lib/rails/worktrees/command/in_repo_worktrees.rb
 - lib/rails/worktrees/command/name_picking.rb
 - lib/rails/worktrees/command/output.rb
 - lib/rails/worktrees/command/post_create_support.rb
@@ -75,12 +76,15 @@ files:
 - lib/rails/worktrees/names/cities.txt
 - lib/rails/worktrees/pi_worktree_config_path.rb
 - lib/rails/worktrees/pi_worktree_config_updater.rb
+- lib/rails/worktrees/playwright_browser_check.rb
 - lib/rails/worktrees/post_create_runner.rb
 - lib/rails/worktrees/procfile_updater.rb
 - lib/rails/worktrees/project_configuration_loader.rb
 - lib/rails/worktrees/project_maintenance.rb
 - lib/rails/worktrees/puma_config_updater.rb
 - lib/rails/worktrees/railtie.rb
+- lib/rails/worktrees/teardown_runner.rb
+- lib/rails/worktrees/teardown_script.rb
 - lib/rails/worktrees/version.rb
 - mise.toml
 - release-please-config.json