gempilot 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72e379c74f157a19076c82e54b15e2d3581610d11089542ebd32b346971cfdb5
-  data.tar.gz: e7b8f296a83f2c4b9e24f4bb3fd7757a034b1cca00fa461f4baa3e5c878b6f51
+  metadata.gz: 686fd797469009843d44529b0831634baf163cbd007a7d625f9605e340aa021a
+  data.tar.gz: f1144a8db6d9a54e8b4cfb146aae7d4d240c92f87a08cf4501589241934cfcbc
 SHA512:
-  metadata.gz: bcb608a185c3808045cf017dcf0629d9b6034be93fd8457129728abed9cfd5191288893c214b3b38a46fdbda267676cdb7976ec2013c053a4b7796cd551a9c73
-  data.tar.gz: 867f02bab2332352a5035db336f5b1073f5d4a4f08f49f75b76b84eb2fdd4d490dba4c9f36fed4b60d0a7844791509dce074d3f13d488b08000e16bc0c70bdc8
+  metadata.gz: 5ae0fdd86a89ec6855ae589c6c64fc28d97e71df117f81a35440ca9029333d962171daf080c8d0b24adafe2e83a4e41e2cb0bd989399d8df9cc79dfb2da6d9b0
+  data.tar.gz: abcea8380c013d64f9f22d8c82a59ffbb18a24ff5bcd0be017c0a640450cec51afc88fb676c0004f797f0a54404ca24e4acc8a2183cd836719dab0e117532580

data/.claude/memory/be-decisive-not-menus.md

@@ -0,0 +1,14 @@
+---
+name: be-decisive-not-menus
+description: "David wants decisive action — make the clear right move, don't present option-menus or re-ask"
+metadata: 
+  node_type: memory
+  type: feedback
+  originSessionId: 8ab20c6a-4c03-4f0a-9acd-e12099699ad8
+---
+
+David wants decisive execution, not deliberation theater. He corrected me repeatedly (and bluntly) this session for presenting choices instead of acting, re-offering things already done, and asking permission for obvious next steps.
+
+**Why:** He's the maintainer and knows his codebase; a menu of options he has to adjudicate is friction, not help. "and?" from him means "keep going / do the next obvious thing." "do the right thing" means "use your judgment and execute."
+
+**How to apply:** When something's already done, say it's done — don't re-offer it. When there's a clear best move (green reviewed PR → merge it; verified-safe branch cleanup → do it), just make it and report the result. Reserve questions for genuine forks where his answer changes the outcome, and even then lead with a one-word-approvable recommendation instead of a survey. Don't narrate options you won't pursue. Confirm only truly hard-to-reverse or outward-facing actions — and expect him to push you past even those with "just do it."

data/.claude/memory/flagship-shared-rubocop-config-state.md

@@ -0,0 +1,16 @@
+---
+name: flagship-shared-rubocop-config-state
+description: "Status of issue 79AE436E (shared RuboCop config + eject) — designed 2026-07-20, not yet built"
+metadata: 
+  node_type: memory
+  type: project
+  originSessionId: 8ab20c6a-4c03-4f0a-9acd-e12099699ad8
+---
+
+The flagship **79AE436E** ("own shared RuboCop config via `inherit_gem` + eject hatch") is **designed but not implemented** as of 2026-07-20. Design spec committed at `docs/superpowers/specs/2026-07-20-shared-rubocop-config-eject-design.md` on branch `file-issue-own-shared-config` (that branch = the flagship WIP: issue-filing commit + design doc only; the 6 backlog fixes that were briefly on it shipped separately via PR #20 and are now in master).
+
+Approved direction: `inherit_gem`; gempilot ships `config/rubocop/{base,minitest,rspec}.yml`; generated `.rubocop.yml` shrinks to near-zero (gem-name excludes become globs `*.gemspec`/`lib/*-*.rb`; drop `TargetRubyVersion` since RuboCop reads it from the gemspec's `required_ruby_version`); new `gempilot eject` inlines config + cuts the link; generated Gemfile pins gempilot.
+
+Before/while building: **(1) OPEN decision** — CI-break mitigation policy; **pin** is the recommended default but David has NOT confirmed it. **(2) First step is a SPIKE** — verify RuboCop loads `plugins:` (rubocop-claude etc.) *through* an `inherit_gem` config; if not, the plugins list stays in the local file. See [[gempilot-generated-gem-rubocop-gate]].
+
+Other open backlog item: **741FFD05** (reduce deps). The gemspec's 4 runtime deps (`command_kit`, `rake`, `warning`, `zeitwerk`) are all used — leave them; reduction is purely Gemfile dev deps. Recommended: drop `benchmark`/`observer`/`rbs`; keep `irb`/`repl_type_completor` (bin/console), `rdoc` (docs), `debug`. (`warning` is the one narrow runtime dep — only silences the VERSION-reload warnings in `Project#fetch_version`.)

data/CLAUDE.md

@@ -10,7 +10,7 @@ A CLI tool for creating and managing Ruby gems, built on CommandKit.
 - `gempilot create` — Scaffold a new gem (templates in `data/templates/gem/`)
 - `gempilot new` — Generate a class, module, or command in an existing gem (templates in `data/templates/new/`)
 - `gempilot destroy` — Remove a class, module, or command from an existing gem
-- `gempilot bump` — Bump version in `version.rb` (patch default, or minor/major)
+- `gempilot bump` — Bump version in `version.rb` (patch default, or minor/major/tiny/dev)
 - `gempilot release` — Thin proxy to `rake release`
 - `gempilot console` — Thin proxy to `bin/console`
 
@@ -21,6 +21,7 @@ A CLI tool for creating and managing Ruby gems, built on CommandKit.
 - Generator module (`lib/gempilot/cli/generator.rb`) provides template rendering via ERB
 - GemContext module (`lib/gempilot/cli/gem_context.rb`) shared by new, destroy, release, console
 - `GemConstant` value object (`lib/gempilot/gem_constant.rb`) owns constant→namespace/path resolution for `new`/`destroy`; constants are rooted at the gem module by construction
+- `SegmentedVersion` value object (`lib/gempilot/segmented_version.rb`) owns version parsing and bump arithmetic; every bump moves to the smallest version of the requested shape greater than the current version (RubyGems ordering)
 - CommandKit::Commands::AutoLoad maps filenames in `commands/` to command names
 
 ### Testing

data/README.md

@@ -82,8 +82,16 @@ Bump the version in `lib/<gem>/version.rb`.
 gempilot bump          # patch (default)
 gempilot bump minor
 gempilot bump major
+gempilot bump tiny     # fourth integer for tiny follow-ups: 0.2.0 -> 0.2.0.1
+gempilot bump dev      # preview of the next patch: 0.2.0 -> 0.2.1.dev1
 ```
 
+A `dev` version previews the next patch, so it always sorts ahead of the
+current release (`0.2.0 < 0.2.1.dev1 < 0.2.1`), and a numeric bump finalizes
+the cycle (`gempilot bump` from `0.2.1.dev3` gives `0.2.1`). A repo holding an
+old-style dev version — one created *after* its base version shipped — needs a
+one-time hand edit of `version.rb` past the last published version.
+
 ### `gempilot release`
 
 Delegates to `rake release`, which publishes the current version to all remotes
@@ -113,7 +121,7 @@ Generated gems include rake tasks for the full version lifecycle:
 | Task | Description |
 |------|-------------|
 | `rake version:current` | Display the current version |
-| `rake version:bump` | Increment the patch version |
+| `rake version:bump` | Bump the version (patch default; major/minor/patch/tiny/dev) |
 | `rake version:commit` | Commit the version file change |
 | `rake version:tag` | Create a git tag for the version |
 | `rake version:untag` | Delete the version git tag |

data/docs/superpowers/plans/2026-08-09-dev-version-bump.md

@@ -0,0 +1,483 @@
+# Forward-Moving Version Bumps Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make every `version:bump` segment move strictly forward under RubyGems ordering, add a `tiny` fourth-integer segment, and mark dev GitHub releases as prereleases.
+
+**Architecture:** A new `Gempilot::SegmentedVersion` value object (Data class) owns parsing of the three accepted version shapes (`M.m.p`, `M.m.p.N`, `M.m.p.devN`) and all bump arithmetic; `Project::Version#bump` becomes a thin delegation, keeping its `Data.define(:path, :value)` surface untouched. `GithubRelease#create` derives prerelease status from its tag string. Spec: `docs/superpowers/specs/2026-08-09-dev-version-bump-design.md`.
+
+**Tech Stack:** Ruby (Zeitwerk autoloading), RSpec (`spec/`, library), Minitest (`test/`, CLI), RuboCop.
+
+## Global Constraints
+
+- Semantics rule (from spec): every bump yields the smallest version of the requested shape strictly greater than the current version. Full transition table is in the spec and is reproduced in Task 1's test code — treat that table as normative.
+- Double-quoted strings (`Style/StringLiterals: double_quotes`); NO `# frozen_string_literal:` comments (`EnforcedStyle: never`); trailing commas in multiline literals/arguments.
+- Ruby ≥ 3.4 idioms are fine (`it` block parameter is used throughout the codebase); rdoc `##` doc blocks (never YARD tags), no blank line between `##` block and the definition.
+- Zeitwerk: new file `lib/gempilot/segmented_version.rb` MUST define `Gempilot::SegmentedVersion` (the eager-load spec `spec/zeitwerk_spec.rb` enforces this).
+- Verification commands: `bundle exec rspec <file>` for focused runs, `bundle exec rake default` (= `test` + `spec` + `rubocop`) for the full gate. Baseline before Task 1: 145 examples, 0 failures, 60 files no rubocop offenses.
+- Commit messages: plain imperative, no conventional-commit prefixes (repo style: "Add issue", "Add dev version bump design spec").
+
+---
+
+### Task 1: SegmentedVersion arithmetic + Version#bump rewrite
+
+**Files:**
+- Create: `lib/gempilot/segmented_version.rb`
+- Modify: `lib/gempilot/project/version.rb` (full rewrite shown below)
+- Test: `spec/gempilot/project/version_spec.rb` (full rewrite shown below)
+- Test: `spec/gempilot/version_task_spec.rb:35-38` (one expectation flip)
+
+**Interfaces:**
+- Consumes: `Gempilot::Project::Version` `Data.define(:path, :value)` (existing), `Data#with` (Ruby core).
+- Produces: `Gempilot::SegmentedVersion.parse(string) → SegmentedVersion` (raises `ArgumentError` on unrecognized shapes), `SegmentedVersion#bump(segment) → SegmentedVersion` for `:major/:minor/:patch/:tiny/:dev` (symbol or string; raises `ArgumentError` otherwise), `SegmentedVersion#to_s → String`. `Version#bump(segment = :patch)` / `#next_version` keep their existing signatures — later tasks rely only on those.
+
+- [ ] **Step 1: Rewrite the version spec with the normative transition table**
+
+Replace the entire contents of `spec/gempilot/project/version_spec.rb` with:
+
+```ruby
+require "spec_helper"
+
+RSpec.describe Gempilot::Project::Version do
+  let(:path) { Pathname("lib/my_gem/version.rb") }
+
+  def version(value)
+    described_class.new(path: path, value: value)
+  end
+
+  describe "#tag" do
+    it "prepends v to the value" do
+      expect(version("1.2.3").tag).to eq("v1.2.3")
+    end
+  end
+
+  describe "#bump" do
+    transitions = {
+      "1.2.3" => { major: "2.0.0", minor: "1.3.0", patch: "1.2.4", tiny: "1.2.3.1", dev: "1.2.4.dev1" },
+      "1.2.3.1" => { major: "2.0.0", minor: "1.3.0", patch: "1.2.4", tiny: "1.2.3.2", dev: "1.2.4.dev1" },
+      "1.2.4.dev2" => { major: "2.0.0", minor: "1.3.0", patch: "1.2.4", tiny: "1.2.4.1", dev: "1.2.4.dev3" },
+      "1.3.0.dev2" => { major: "2.0.0", minor: "1.3.0", patch: "1.3.0", tiny: "1.3.0.1", dev: "1.3.0.dev3" },
+      "2.0.0.dev2" => { major: "2.0.0", minor: "2.0.0", patch: "2.0.0", tiny: "2.0.0.1", dev: "2.0.0.dev3" },
+    }
+
+    transitions.each do |from, bumps|
+      bumps.each do |segment, to|
+        it "bumps #{from} to #{to} for #{segment}" do
+          expect(version(from).bump(segment).value).to eq(to)
+        end
+      end
+    end
+
+    it "moves every transition strictly forward under Gem::Version ordering" do
+      transitions.each do |from, bumps|
+        bumps.each_value do |to|
+          expect(Gem::Version.new(to)).to be > Gem::Version.new(from)
+        end
+      end
+    end
+
+    it "bumps patch by default" do
+      expect(version("1.2.3").bump.value).to eq("1.2.4")
+    end
+
+    it "accepts segment as a string" do
+      expect(version("1.0.0").bump("minor").value).to eq("1.1.0")
+    end
+
+    it "raises for an unknown segment" do
+      expect { version("1.0.0").bump(:hotfix) }.to raise_error(ArgumentError, /unknown segment/i)
+    end
+
+    it "raises for a two-integer version" do
+      expect { version("1.2").bump }.to raise_error(ArgumentError, /cannot parse/i)
+    end
+
+    it "raises for a non-dev prerelease version" do
+      expect { version("1.2.3.beta1").bump }.to raise_error(ArgumentError, /cannot parse/i)
+    end
+  end
+
+  describe "#next_version" do
+    it "finalizes a dev version to its target" do
+      expect(version("0.0.4.dev3").next_version.value).to eq("0.0.4")
+    end
+
+    it "bumps the patch of a release version" do
+      expect(version("1.0.99").next_version.value).to eq("1.0.100")
+    end
+  end
+end
+```
+
+- [ ] **Step 2: Flip the stale expectation in the version task spec**
+
+In `spec/gempilot/version_task_spec.rb`, the fixture version is `1.0.0.dev3`. Change the `version:bump` default example (currently expects `"1.0.1"`) to:
+
+```ruby
+    it "finalizes a dev version to its target by default" do
+      Rake::Task["version:bump"].invoke
+      expect(version_in_file).to eq("1.0.0")
+    end
+```
+
+(The `version:bump[dev]` → `"1.0.0.dev4"` and both `version:release` examples are already correct under the new semantics — do not touch them.)
+
+- [ ] **Step 3: Run the specs to verify they fail for the right reason**
+
+Run: `bundle exec rspec spec/gempilot/project/version_spec.rb spec/gempilot/version_task_spec.rb --no-color`
+Expected: FAILURES including `expected: "1.2.4.dev1" got: "1.2.3.dev1"` (dev goes backward today), `expected: "1.2.4" got: "1.2.5"` (patch overshoots a dev target), every `:tiny` cell erroring with `ArgumentError: Unknown segment :tiny` (old code rejects the segment), the `"1.2"` example failing with `NoMethodError` instead of `ArgumentError` (old code coerces then crashes on the missing patch integer), the `"1.2.3.beta1"` example failing with "expected ArgumentError but nothing was raised" (old code silently coerces to `1.2.4`), and `expected: "1.0.0" got: "1.0.1"` in the task spec. The `#tag`, string-segment, and unknown-segment examples still pass.
+
+- [ ] **Step 4: Create the SegmentedVersion value object**
+
+Create `lib/gempilot/segmented_version.rb`:
+
+```ruby
+module Gempilot
+  ## Arithmetic over the three version shapes gempilot accepts: release
+  ## (+1.2.3+), tiny release (+1.2.3.1+), and dev prerelease (+1.2.3.dev1+).
+  ##
+  ## Every bump returns the smallest version of the requested shape that is
+  ## strictly greater than the current version under RubyGems ordering, so
+  ## bumping always moves a project forward: a dev bump previews the next
+  ## patch (+1.2.3+ to +1.2.4.dev1+) and numeric bumps finalize a dev cycle
+  ## (+1.2.4.dev2+ to +1.2.4+ for +:patch+).
+  SegmentedVersion = Data.define(:major, :minor, :patch, :tiny, :dev) do
+    def self.parse(string)
+      format = /\A(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?:\.(?<tiny>\d+)|\.dev(?<dev>\d+))?\z/
+      match = format.match(string)
+      raise ArgumentError, "cannot parse version: #{string.inspect}" unless match
+
+      new(**match.named_captures.to_h { |name, digits| [name.to_sym, digits&.to_i] })
+    end
+
+    def bump(segment)
+      case segment.to_sym
+      when :major then bump_major
+      when :minor then bump_minor
+      when :patch then bump_patch
+      when :tiny  then bump_tiny
+      when :dev   then bump_dev
+      else raise ArgumentError, "Unknown segment #{segment.inspect}. Use :major, :minor, :patch, :tiny, or :dev"
+      end
+    end
+
+    def to_s
+      [major, minor, patch, tiny, ("dev#{dev}" if dev)].compact.join(".")
+    end
+
+    private
+
+    def bump_major
+      return finalize if dev && minor.zero? && patch.zero?
+
+      with(major: major + 1, minor: 0, patch: 0, tiny: nil, dev: nil)
+    end
+
+    def bump_minor
+      return finalize if dev && patch.zero?
+
+      with(minor: minor + 1, patch: 0, tiny: nil, dev: nil)
+    end
+
+    def bump_patch
+      dev ? finalize : with(patch: patch + 1, tiny: nil)
+    end
+
+    def bump_tiny
+      with(tiny: (tiny || 0) + 1, dev: nil)
+    end
+
+    def bump_dev
+      dev ? with(dev: dev + 1) : with(patch: patch + 1, tiny: nil, dev: 1)
+    end
+
+    def finalize
+      with(tiny: nil, dev: nil)
+    end
+  end.freeze
+end
+```
+
+Notes for the implementer:
+- The regex lives in a method-local (`format`), not a constant — a constant inside the `Data.define` block would trip `Lint/ConstantDefinitionInBlock`.
+- `bump` dispatches to five one-branch private methods to stay under `Metrics/CyclomaticComplexity` (max 7).
+- `finalize` drops the prerelease/tiny suffix — it encodes "the smallest version of a numeric shape greater than a dev version is the dev version's own target".
+
+- [ ] **Step 5: Rewrite Version#bump as a delegation**
+
+Replace the entire contents of `lib/gempilot/project/version.rb` with:
+
+```ruby
+module Gempilot
+  class Project
+    ## The project's version file (+path+) and value. Bump arithmetic
+    ## delegates to SegmentedVersion, so every bump moves strictly forward
+    ## under RubyGems ordering.
+    Version = Data.define(:path, :value) do
+      def tag
+        "v#{value}"
+      end
+
+      def bump(segment = :patch)
+        with(value: SegmentedVersion.parse(value).bump(segment).to_s)
+      end
+
+      alias_method :next_version, :bump
+    end.freeze
+  end
+end
+```
+
+- [ ] **Step 6: Run the specs to verify they pass**
+
+Run: `bundle exec rspec spec/gempilot/project/version_spec.rb spec/gempilot/version_task_spec.rb --no-color`
+Expected: PASS, 0 failures (34 + task-spec examples). If `zeitwerk` cannot resolve the new constant, the filename does not match `Gempilot::SegmentedVersion` — fix the filename, not the loader.
+
+- [ ] **Step 7: Run the full gate**
+
+Run: `bundle exec rake default 2>&1 | tail -8`
+Expected: minitest green, all RSpec examples green (count grows from 145), `no offenses detected`.
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add lib/gempilot/segmented_version.rb lib/gempilot/project/version.rb spec/gempilot/project/version_spec.rb spec/gempilot/version_task_spec.rb
+git commit -m "Make version bumps move strictly forward"
+```
+
+---
+
+### Task 2: `tiny` segment on the rake and CLI surfaces
+
+**Files:**
+- Modify: `lib/gempilot/version_task.rb:53` (desc string only)
+- Modify: `lib/gempilot/cli/commands/bump.rb`
+- Test: `spec/gempilot/version_task_spec.rb` (add one example)
+- Test: `test/gempilot/cli/bump_command_test.rb` (add one test)
+
+**Interfaces:**
+- Consumes: `Version#bump` accepting `:tiny` (Task 1); rake `version:bump[segment]` forwards the segment string verbatim (existing behavior — no logic change needed there).
+- Produces: `gempilot bump tiny` and `rake version:bump[tiny]` as documented user commands; CLI allowed-segment list `%w[patch minor major tiny dev]`.
+
+- [ ] **Step 1: Add the failing rake-task example**
+
+In `spec/gempilot/version_task_spec.rb`, inside `describe "version:bump"`, add:
+
+```ruby
+    it "bumps the tiny segment" do
+      Rake::Task["version:bump"].invoke("tiny")
+      expect(version_in_file).to eq("1.0.0.1")
+    end
+```
+
+(Fixture is `1.0.0.dev3`; `tiny` finalizes the core and appends `.1`.)
+
+- [ ] **Step 2: Add the failing CLI test**
+
+In `test/gempilot/cli/bump_command_test.rb`, after `test_bump_dev_invokes_rake`, add:
+
+```ruby
+      def test_bump_tiny_invokes_rake
+        calls = recorded_system_calls { |cmd| cmd.main(["tiny"]) }
+
+        assert_includes calls, ["bundle", "exec", "rake", "version:bump[tiny]"]
+      end
+```
+
+- [ ] **Step 3: Run both to verify the CLI test fails and the rake example passes**
+
+Run: `bundle exec rspec spec/gempilot/version_task_spec.rb --no-color && bundle exec rake test 2>&1 | tail -4`
+Expected: the rake-task example PASSES already (the task forwards any segment and Task 1 taught `Version#bump` about `:tiny`) — it is a pin, not a driver. The minitest CLI test FAILS: `Bump#validate_segment` rejects `tiny` and exits 1 before calling rake.
+
+- [ ] **Step 4: Teach the CLI command the tiny segment**
+
+In `lib/gempilot/cli/commands/bump.rb` apply these four edits:
+
+```ruby
+        description "Bump the gem version (patch by default, or minor/major/tiny/dev)"
+
+        examples [
+          "",
+          "patch",
+          "minor",
+          "major",
+          "tiny",
+          "dev",
+        ]
+
+        argument :segment, required: false,
+                           desc: "Version segment to bump: patch (default), minor, major, tiny, or dev"
+```
+
+and in `validate_segment`:
+
+```ruby
+          return segment if %w[patch minor major tiny dev].include?(segment)
+
+          puts colors.red("Unknown segment '#{segment}'. Use patch, minor, major, tiny, or dev.")
+```
+
+- [ ] **Step 5: Update the rake task description**
+
+In `lib/gempilot/version_task.rb`, `define_bump_task`:
+
+```ruby
+      desc "Bump version (patch default; segments: major, minor, patch, tiny, dev)"
+```
+
+- [ ] **Step 6: Run the full gate**
+
+Run: `bundle exec rake default 2>&1 | tail -8`
+Expected: all green, no offenses. (`test_bump_fails_with_invalid_segment` uses `hotfix`, which stays invalid.)
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add lib/gempilot/version_task.rb lib/gempilot/cli/commands/bump.rb spec/gempilot/version_task_spec.rb test/gempilot/cli/bump_command_test.rb
+git commit -m "Add tiny segment to bump interfaces"
+```
+
+---
+
+### Task 3: Mark dev GitHub releases as prereleases
+
+**Files:**
+- Modify: `lib/gempilot/github_release.rb`
+- Test: `spec/gempilot/github_release_spec.rb`
+
+**Interfaces:**
+- Consumes: `GithubRelease.new(tag)` with tag strings like `"v1.2.4.dev1"` (signature unchanged); `Gem::Version#prerelease?` (rubygems, always loaded).
+- Produces: `gh release create` invoked with `--prerelease` when and only when the tag names a prerelease version.
+
+- [ ] **Step 1: Add the failing specs**
+
+In `spec/gempilot/github_release_spec.rb`, inside `describe "#create"`, add two contexts after the existing examples:
+
+```ruby
+    context "with a dev prerelease tag" do
+      let(:tag) { "v1.2.4.dev1" }
+
+      it "marks the release as a prerelease" do
+        release.create
+        args = ["gh", "release", "create", "--generate-notes", "--fail-on-no-commits", "--prerelease", tag]
+        expect(release).to have_received(:sh).with(*args)
+      end
+    end
+
+    context "with a tiny release tag" do
+      let(:tag) { "v1.2.3.1" }
+
+      it "does not mark the release as a prerelease" do
+        release.create
+        args = ["gh", "release", "create", "--generate-notes", "--fail-on-no-commits", tag]
+        expect(release).to have_received(:sh).with(*args)
+      end
+    end
+```
+
+- [ ] **Step 2: Run to verify the dev context fails**
+
+Run: `bundle exec rspec spec/gempilot/github_release_spec.rb --no-color`
+Expected: FAIL — the dev-tag example receives no `--prerelease` argument; the tiny-tag example passes.
+
+- [ ] **Step 3: Implement the prerelease flag**
+
+In `lib/gempilot/github_release.rb`, replace `#create` and append a private section after `#list`:
+
+```ruby
+    def create
+      sh "gh", "release", "create",
+         "--generate-notes", "--fail-on-no-commits",
+         *prerelease_flag,
+         tag
+    end
+```
+
+```ruby
+    private
+
+    def prerelease_flag
+      Gem::Version.new(tag.delete_prefix("v")).prerelease? ? ["--prerelease"] : []
+    end
+```
+
+Also extend the class doc block's first line to:
+
+```ruby
+  ## Manages GitHub releases for a version tag. Tags naming a prerelease
+  ## version (e.g. +v1.2.4.dev1+) are created as GitHub prereleases.
+```
+
+- [ ] **Step 4: Run the spec, then the full gate**
+
+Run: `bundle exec rspec spec/gempilot/github_release_spec.rb --no-color && bundle exec rake default 2>&1 | tail -8`
+Expected: PASS everywhere, no offenses.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add lib/gempilot/github_release.rb spec/gempilot/github_release_spec.rb
+git commit -m "Mark dev GitHub releases as prereleases"
+```
+
+---
+
+### Task 4: Documentation
+
+**Files:**
+- Modify: `README.md` (bump section ~line 77-85; version tasks table row ~line 116)
+- Modify: `CLAUDE.md` (bump command bullet; architecture list)
+
+**Interfaces:**
+- Consumes: final semantics from Tasks 1-3.
+- Produces: user-facing docs; no code.
+
+- [ ] **Step 1: Update the README bump section**
+
+Replace the `gempilot bump` code block and add one paragraph after it:
+
+````markdown
+```bash
+gempilot bump          # patch (default)
+gempilot bump minor
+gempilot bump major
+gempilot bump tiny     # fourth integer for tiny follow-ups: 0.2.0 -> 0.2.0.1
+gempilot bump dev      # preview of the next patch: 0.2.0 -> 0.2.1.dev1
+```
+
+A `dev` version previews the next patch, so it always sorts ahead of the
+current release (`0.2.0 < 0.2.1.dev1 < 0.2.1`), and a numeric bump finalizes
+the cycle (`gempilot bump` from `0.2.1.dev3` gives `0.2.1`). A repo holding an
+old-style dev version — one created *after* its base version shipped — needs a
+one-time hand edit of `version.rb` past the last published version.
+````
+
+- [ ] **Step 2: Update the README version tasks table row**
+
+```markdown
+| `rake version:bump` | Bump the version (patch default; major/minor/patch/tiny/dev) |
+```
+
+- [ ] **Step 3: Update CLAUDE.md**
+
+Change the bump command bullet to:
+
+```markdown
+- `gempilot bump` — Bump version in `version.rb` (patch default, or minor/major/tiny/dev)
+```
+
+and add to the Architecture list, after the `GemConstant` bullet:
+
+```markdown
+- `SegmentedVersion` value object (`lib/gempilot/segmented_version.rb`) owns version parsing and bump arithmetic; every bump moves to the smallest version of the requested shape greater than the current version (RubyGems ordering)
+```
+
+- [ ] **Step 4: Full gate and commit**
+
+Run: `bundle exec rake default 2>&1 | tail -8`
+Expected: all green (docs only — this is a regression guard).
+
+```bash
+git add README.md CLAUDE.md
+git commit -m "Update docs for forward-moving version bumps"
+```

data/docs/superpowers/specs/2026-08-09-dev-version-bump-design.md

@@ -0,0 +1,163 @@
+# Dev version bump semantics — design
+
+**Issue:** `2360FFA4-9388-11F1-8474-FE6CB9572C2F` — "rake version:bump[dev] goes backward rather than forward"
+
+**Date:** 2026-08-09
+
+## Problem
+
+`Gempilot::Project::Version#bump(:dev)` appends `.dev1` to the *current* version
+(`0.2.0` → `0.2.0.dev1`). RubyGems treats any version with a letter segment as a
+**prerelease of the version it names** (`Gem::Version` rdoc: "Prereleases sort
+between real releases (newest to oldest): 1.0 > 1.0.b1 > 1.0.a.2 > 0.9"), so
+`0.2.0.dev1 < 0.2.0` — the bump moves the project *backward*. Two related gaps:
+
+1. `bump(:patch)` from `X.Y.Z.devN` produces `X.Y.(Z+1)`, overshooting the
+   `X.Y.Z` the dev cycle was working toward.
+2. There is no way to bump a fourth integer (`0.2.0` → `0.2.0.1`), the
+   rubygems-legal *non-prerelease* shape for tiny follow-up fixes on a released
+   version (the Rails security-release pattern, `6.0.3.1`).
+
+## Decisions
+
+- **Dev versions preview the next patch.** `bump(:dev)` from a release version
+  yields the next patch's first dev prerelease (`0.2.0` → `0.2.1.dev1`); from a
+  dev version it increments the counter (`0.2.1.dev1` → `0.2.1.dev2`). This is
+  the only reading consistent with rubygems ordering, and matches ecosystem
+  practice (Rails `7.1.0.beta1` precedes `7.1.0`; Bundler's in-repo `.dev`).
+- **One rule governs every bump: move to the smallest version of the requested
+  shape that is strictly greater than the current version.** Consequences:
+  numeric bumps from a dev version *finalize* the cycle (`0.2.1.dev3` +
+  `patch` → `0.2.1`, not `0.2.2`), and `minor`/`major` redirect it
+  (`0.2.1.dev3` + `minor` → `0.3.0`).
+- **New `tiny` segment for the fourth integer.** `bump(:tiny)`: `0.2.0` →
+  `0.2.0.1` → `0.2.0.2`. Name chosen by elimination: semver's "build metadata"
+  is precedence-ignored (and the `Gem::Version` rdoc uses "build" for the third
+  integer); `micro` is Python's third digit; `patchlevel` is Ruby-historical but
+  long and confusable with `patch`. `tiny` reads as "smaller than patch", which
+  is where it sorts. (Old Rails used TINY for the third digit; accepted.)
+- **No dev target argument** (`bump[dev,minor]` → `0.3.0.dev1`) — YAGNI. The
+  shape rule already finalizes hand-edited `M.m.0.devN` / `M.0.0.devN` states
+  correctly, so a targeted form can be layered on later without breaking
+  anything.
+- **Dev GitHub releases are prereleases.** `release:github` passes
+  `--prerelease` to `gh release create` when the tag names a prerelease
+  version, so `v0.2.1.dev2` does not become the repo's "Latest" release.
+- **Strict version parsing.** `Version#bump` recognizes exactly three forms —
+  `M.m.p`, `M.m.p.N`, `M.m.p.devN` — and raises `ArgumentError` for anything
+  else, instead of today's silent first-three-integers coercion.
+
+## Semantics
+
+Accepted version forms: release `M.m.p`, tiny release `M.m.p.N`, dev prerelease
+`M.m.p.devN` (parse: `/\A(\d+)\.(\d+)\.(\d+)(?:\.(\d+)|\.dev(\d+))?\z/`).
+
+Full transition table (rows marked * arise only by hand-editing; the rule is
+total over all three forms regardless of how the version got there):
+
+| from ↓ bump → | `major` | `minor` | `patch` | `tiny`    | `dev`        |
+| ------------- | ------- | ------- | ------- | --------- | ------------ |
+| `1.2.3`       | `2.0.0` | `1.3.0` | `1.2.4` | `1.2.3.1` | `1.2.4.dev1` |
+| `1.2.3.1`     | `2.0.0` | `1.3.0` | `1.2.4` | `1.2.3.2` | `1.2.4.dev1` |
+| `1.2.4.dev2`  | `2.0.0` | `1.3.0` | `1.2.4` | `1.2.4.1` | `1.2.4.dev3` |
+| `1.3.0.dev2`* | `2.0.0` | `1.3.0` | `1.3.0` | `1.3.0.1` | `1.3.0.dev3` |
+| `2.0.0.dev2`* | `2.0.0` | `2.0.0` | `2.0.0` | `2.0.0.1` | `2.0.0.dev3` |
+
+All 25 transitions verified strictly increasing under `Gem::Version` (checked
+2026-08-09 against ruby's installed rubygems).
+
+Branch logic per segment, where the numeric core is `M.m.p` and `dev?` means
+the current version is a dev prerelease:
+
+- `major`: `dev? && m == 0 && p == 0` → `M.0.0` (finalize); else `(M+1).0.0`
+- `minor`: `dev? && p == 0` → `M.m.0` (finalize); else `M.(m+1).0`
+- `patch`: `dev?` → `M.m.p` (finalize); else `M.m.(p+1)`
+- `tiny`:  `M.m.p.(N+1)` where `N` is the current fourth integer, else 0.
+  (From a dev version this yields `M.m.p.1` — it implicitly finalizes the
+  target and adds a tiny level; forward-moving, documented edge case.)
+- `dev`:   `dev?` → `M.m.p.dev(N+1)`; else `M.m.(p+1).dev1`
+
+## Components
+
+### `Gempilot::Project::Version` (modified — `lib/gempilot/project/version.rb`)
+
+- Stays `Data.define(:path, :value)` — `write_version!`, `VersionTag`, and all
+  call sites are untouched. Parsing is internal to `bump`.
+- `bump(segment)` accepts `:major, :minor, :patch, :tiny, :dev` (symbol or
+  string), implements the table above. Unknown segment → `ArgumentError`
+  naming the valid segments (as today, plus `tiny`). Unparseable value →
+  `ArgumentError` naming the value.
+- `next_version` alias retained; its behavior follows the new `patch` default
+  (`0.0.4.dev3` → `0.0.4`, previously `0.0.5`).
+
+### `Gempilot::GithubRelease` (modified — `lib/gempilot/github_release.rb`)
+
+- `#create` appends `--prerelease` when the tag (sans leading `v`) parses as a
+  prerelease per `Gem::Version#prerelease?`. Self-contained — the
+  `initialize(tag)` signature and all call sites are unchanged. `#destroy` /
+  `#list` untouched.
+
+### `Gempilot::VersionTask` (modified — `lib/gempilot/version_task.rb`)
+
+- Behavior unchanged (it forwards the segment). Only the `version:bump` desc
+  string updates: "Bump version (patch default; segments: major, minor, patch,
+  tiny, dev)".
+
+### `Gempilot::CLI::Commands::Bump` (modified — `lib/gempilot/cli/commands/bump.rb`)
+
+- Allowed segments become `%w[patch minor major tiny dev]`; error message,
+  argument desc, command description, and `examples` updated to match.
+
+## Testing (TDD — written before implementation)
+
+**`spec/gempilot/project/version_spec.rb` (rewritten)**
+
+- The full 5×5 transition table above, each cell an example.
+- A monotonicity property spec: for every table cell,
+  `Gem::Version.new(new) > Gem::Version.new(old)` — the direct regression spec
+  for this issue.
+- Segment as string; unknown segment `ArgumentError`; unparseable value
+  (`"1.2"`, `"1.2.3.beta1"`) `ArgumentError`; `next_version` follows patch
+  semantics (`0.0.4.dev3` → `0.0.4`).
+
+**`spec/gempilot/version_task_spec.rb` (expectations updated)**
+
+Fixture starts at `1.0.0.dev3`:
+- `version:bump` (default patch) → `1.0.0` (finalize; was `1.0.1`).
+- `version:bump[dev]` → `1.0.0.dev4` (unchanged).
+- `version:bump[tiny]` → `1.0.0.1` (new example).
+- `version:release[dev]` → commit "Bump version to 1.0.0.dev4", tag
+  `v1.0.0.dev4` (unchanged).
+
+**`spec/gempilot/github_release_spec.rb` (extended)**
+
+- `create` with `v1.2.4.dev1` includes `--prerelease`; with `v1.2.4` and
+  `v1.2.3.1` it does not.
+
+**`test/gempilot/cli/bump_command_test.rb` (extended)**
+
+- `tiny` accepted as a segment; unknown-segment error message lists it.
+
+## Docs
+
+- `README.md` — `gempilot bump` section gains `tiny` and `dev` examples with a
+  one-line explanation of dev semantics; the rake tasks table row for
+  `version:bump` mentions the segments.
+- `CLAUDE.md` — version lifecycle bullet: "(patch default, or
+  minor/major/tiny/dev)".
+
+## Migration
+
+A repo sitting on an old-style dev version (e.g. `0.2.0.dev1` created *after*
+`0.2.0` shipped) is already in the broken state this fixes; `bump(:patch)`
+would finalize to the already-released `0.2.0` (and `version:tag` would then
+fail on the existing tag). Recovery is a one-time hand edit of `version.rb`
+past the last published version. Noted in the README dev-example line.
+
+## Out of scope
+
+- Targeted dev cycles (`bump[dev,minor]`) — compatible later extension.
+- Other prerelease markers (`pre`, `rc`, `beta`) — `dev` sorts before all of
+  them, so they remain addable later.
+- RubyGems prerelease yanking; `data/templates/gem/Rakefile.erb` (no change
+  needed — it just instantiates `Gempilot::VersionTask`).

data/issues.rec

@@ -110,8 +110,8 @@ Description: e.g.
 +  Zeitwerk::Loader.for_gem.tap do |l|
 +     l.setup
 +   end
-+
-+
++ 
++ 
 Status: closed
 
 Id: 5618BB20-4325-11F1-BF5A-FE6CB9572C2F
@@ -212,3 +212,91 @@ Description: the github release related tasks are invoked as follows:
 + 
 + Also, there is an issue that prevents github releasing from working at all via the old tasks. I get an error every time saying that "tags have already been pushed" or something along those lines. Ensure that is fixed as well
 Status: closed
+
+Id: 986E0100-88F4-11F1-B718-FE6CB9572C2D
+Updated: Sun, 26 Jul 2026 09:19:13 -0400
+Title: Make rbs and the other gems GP installs mri only
+Description: This tool is also used with jruby, and it fails irb install due to rbs
+Status: open
+
+Id: 3FFE7616-88F5-11F1-8D3B-FE6CB9572C2D
+Updated: Sun, 26 Jul 2026 09:23:54 -0400
+Title: Add betterleaks to gem setup
+Description: Ensure betterleaks is integrated into the commit and build pipelines, via commit hooks, rake tasks, and/or whatever the idiomatic way is to integrate betterleaks into a rubyproject
+Status: open
+
+Id: F6C6EB04-8DA4-11F1-91EF-FA41C3164F3A
+Updated: Sat, 01 Aug 2026 12:31:47 +0000
+Title: release:rubygem_push only handles one gem per version
+Description: rake release:rubygems can publish only one gem per version. A project that publishes several -- platform gems each carrying a compiled executable, say -- either publishes one of them and silently leaves the rest, or, once it replaces the push task with a pkg glob, tries to re-push versions already on rubygems and stops halfway through the release.
++ 
++ MECHANISM
++ 
++ gempilot, lib/gempilot/release_tasks.rb: ReleaseTasks#define_rubygems_release wires release:rubygems to [build, release:guard_clean, release:source_control_push, release:rubygem_push], and, as the module's own rdoc says, expects bundler/gem_tasks to have supplied build, release:guard_clean and release:rubygem_push.
++ 
++ bundler 4.0.17, lib/bundler/gem_helper.rb: GemHelper#install_tasks defines
++ 
++   task "release:rubygem_push" => "build" do
++     rubygem_push(built_gem_path) if gem_push?
++   end
++ 
++ built_gem_path is the single .gem that #build_gem produced. One build, one gem, one push. Nothing in that chain can carry a second gem, so a project publishing more than one has to replace both build and release:rubygem_push itself.
++ 
++ There is no glob in gempilot's own source to go looking for. The glob is what a downstream project ends up writing once it takes over the push, and it is wrong in a way gempilot's own version:bump triggers.
++ 
++ REPRODUCE
++ 
++ 1. A gem publishing more than one gem per version. aws-session-manager on gempilot 0.3.0 publishes five: x86_64-linux, aarch64-linux, x86_64-darwin and arm64-darwin, each carrying a compiled session-manager-plugin executable, plus the plain ruby gem.
++ 2. It replaces build, and replaces the push with the obvious implementation:
++      task(:rubygem_push) { PACKAGES.glob("*.gem").each { sh "gem", "push", it.to_s } }
++ 3. rake build && rake release:rubygems -- 0.0.1 publishes.
++ 4. rake version:bump && rake build -- pkg/ now holds both 0.0.1 and 0.0.2 gems. Nothing empties pkg/ between versions; bundler never has, and gempilot's version tasks do not either.
++ 5. rake release:rubygems -- gem push rejects the 0.0.1 gems ("Repushing of gem versions is not allowed"), sh raises on the non-zero status, and the release aborts with part of 0.0.2 published and the rest not. Re-running repeats the failure, because the stale gems are still there.
++ 
++ FIX APPLIED DOWNSTREAM
++ 
++ aws-session-manager stopped globbing and took the list from the specifications its build packages, so that gem:build and the push share one source of truth:
++ 
++   PACKAGED = [*BUILDS.map { it.package.to_s }, GENERIC_PACKAGE].freeze
++ 
++   namespace :gem do
++     task build: PACKAGED
++   end
++ 
++   namespace :release do
++     task(:rubygem_push) { PACKAGED.each { sh "gem", "push", it } }
++   end
++ 
++ FIX SUGGESTED HERE
++ 
++ gempilot should own release:rubygem_push rather than inherit bundler's, and push every gem in pkg belonging to the version being released. It cannot know how a project builds, but it knows the name and the version, which is enough:
++ 
++   def define_rubygem_push(project)
++     clear_task "release:rubygem_push"
++     task "release:rubygem_push" => "build" do
++       packages(project).each { sh "gem", "push", it.to_s }
++     end
++   end
++ 
++   def packages(project)
++     stem = "#{project.name}-#{project.version_value}"
++     project.root.glob("pkg/{#{stem}.gem,#{stem}-*.gem}")
++   end
++ 
++ Project#name, #version_value and #root already exist in lib/gempilot/project.rb.
++ 
++ Two details worth keeping:
++ 
++ - The brace glob matches gempilot-0.3.0.gem and gempilot-0.3.0-x86_64-linux.gem, and does not match gempilot-0.3.10.gem. A bare "#{stem}*.gem" would match the latter and push the wrong version.
++ - An empty result should abort. Otherwise a project whose build writes gems elsewhere gets a release that reports success having published nothing, which is worse than the bug being fixed.
++ 
++ Single-gem projects are unaffected: pkg holds one gem for the current version, and it gets pushed, as today. Multi-gem projects stop having to reinvent the push.
++ 
++ If gempilot would rather not own the task, then the ReleaseTasks rdoc should state the contract instead: a project that replaces build must also replace release:rubygem_push, and must scope the push to the version being released rather than globbing pkg.
+Status: open
+
+Id: 2360FFA4-9388-11F1-8474-FE6CB9572C2F
+Updated: Sat, 08 Aug 2026 20:20:34 -0400
+Title: rake version:bump[dev] goes backward rather than forward
+Description: rubygems treats 0.2.0.dev as an *older* version than 0.2.0. The way gempilot handles dev version needs to be rethought. Additionally, how does a user trigger a bump on the fourth integer, e.g. 0.2.0.1?
+Status: open

data/lib/gempilot/cli/commands/bump.rb

@@ -8,18 +8,19 @@ module Gempilot
         include GemContext
 
         usage "[options] [SEGMENT]"
-        description "Bump the gem version (patch by default, or minor/major/dev)"
+        description "Bump the gem version (patch by default, or minor/major/tiny/dev)"
 
         examples [
           "",
           "patch",
           "minor",
           "major",
+          "tiny",
           "dev",
         ]
 
         argument :segment, required: false,
-                           desc: "Version segment to bump: patch (default), minor, major, or dev"
+                           desc: "Version segment to bump: patch (default), minor, major, tiny, or dev"
 
         def run(segment = "patch")
           detect_gem_context
@@ -31,9 +32,9 @@ module Gempilot
 
         def validate_segment(segment)
           segment = segment.downcase
-          return segment if %w[patch minor major dev].include?(segment)
+          return segment if %w[patch minor major tiny dev].include?(segment)
 
-          puts colors.red("Unknown segment '#{segment}'. Use patch, minor, major, or dev.")
+          puts colors.red("Unknown segment '#{segment}'. Use patch, minor, major, tiny, or dev.")
           exit 1
         end
 

data/lib/gempilot/github_release.rb

@@ -1,5 +1,6 @@
 module Gempilot
-  ## Manages GitHub releases for a version tag.
+  ## Manages GitHub releases for a version tag. Tags naming a prerelease
+  ## version (e.g. +v1.2.4.dev1+) are created as GitHub prereleases.
   class GithubRelease
     include StrictShell
 
@@ -12,6 +13,7 @@ module Gempilot
     def create
       sh "gh", "release", "create",
          "--generate-notes", "--fail-on-no-commits",
+         *prerelease_flag,
          tag
     end
 
@@ -24,5 +26,11 @@ module Gempilot
     def list
       sh "gh", "release", "list"
     end
+
+    private
+
+    def prerelease_flag
+      Gem::Version.new(tag.delete_prefix("v")).prerelease? ? ["--prerelease"] : []
+    end
   end
 end

data/lib/gempilot/project/version.rb

@@ -1,36 +1,15 @@
 module Gempilot
   class Project
+    ## The project's version file (+path+) and value. Bump arithmetic
+    ## delegates to SegmentedVersion, so every bump moves strictly forward
+    ## under RubyGems ordering.
     Version = Data.define(:path, :value) do
       def tag
         "v#{value}"
       end
 
       def bump(segment = :patch)
-        case segment.to_sym
-        when :major, :minor, :patch then bump_semver(segment)
-        when :dev                   then bump_dev
-        else raise ArgumentError, "Unknown segment #{segment.inspect}. Use :major, :minor, :patch, or :dev"
-        end
-      end
-
-      private
-
-      def bump_semver(segment)
-        major, minor, patch = value.split(".").first(3).map(&:to_i)
-        new_value = case segment.to_sym
-                    when :major then "#{major + 1}.0.0"
-                    when :minor then "#{major}.#{minor + 1}.0"
-                    when :patch then "#{major}.#{minor}.#{patch + 1}"
-                    end
-        with(value: new_value)
-      end
-
-      def bump_dev
-        if value.match?(/\.dev\d+\z/)
-          with(value: value.sub(/\d+\z/) { it.to_i + 1 })
-        else
-          with(value: "#{value}.dev1")
-        end
+        with(value: SegmentedVersion.parse(value).bump(segment).to_s)
       end
 
       alias_method :next_version, :bump

data/lib/gempilot/segmented_version.rb

@@ -0,0 +1,64 @@
+module Gempilot
+  ## Arithmetic over the three version shapes gempilot accepts: release
+  ## (+1.2.3+), tiny release (+1.2.3.1+), and dev prerelease (+1.2.3.dev1+).
+  ##
+  ## Every bump returns the smallest version of the requested shape that is
+  ## strictly greater than the current version under RubyGems ordering, so
+  ## bumping always moves a project forward: a dev bump previews the next
+  ## patch (+1.2.3+ to +1.2.4.dev1+) and numeric bumps finalize a dev cycle
+  ## (+1.2.4.dev2+ to +1.2.4+ for +:patch+).
+  SegmentedVersion = Data.define(:major, :minor, :patch, :tiny, :dev) do
+    def self.parse(string)
+      format = /\A(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?:\.(?<tiny>\d+)|\.dev(?<dev>\d+))?\z/
+      match = format.match(string)
+      raise ArgumentError, "cannot parse version: #{string.inspect}" unless match
+
+      new(**match.named_captures.to_h { |name, digits| [name.to_sym, digits&.to_i] })
+    end
+
+    def bump(segment)
+      case segment.to_sym
+      when :major then bump_major
+      when :minor then bump_minor
+      when :patch then bump_patch
+      when :tiny  then bump_tiny
+      when :dev   then bump_dev
+      else raise ArgumentError, "Unknown segment #{segment.inspect}. Use :major, :minor, :patch, :tiny, or :dev"
+      end
+    end
+
+    def to_s
+      [major, minor, patch, tiny, ("dev#{dev}" if dev)].compact.join(".")
+    end
+
+    private
+
+    def bump_major
+      return finalize if dev && minor.zero? && patch.zero?
+
+      with(major: major + 1, minor: 0, patch: 0, tiny: nil, dev: nil)
+    end
+
+    def bump_minor
+      return finalize if dev && patch.zero?
+
+      with(minor: minor + 1, patch: 0, tiny: nil, dev: nil)
+    end
+
+    def bump_patch
+      dev ? finalize : with(patch: patch + 1, tiny: nil)
+    end
+
+    def bump_tiny
+      with(tiny: (tiny || 0) + 1, dev: nil)
+    end
+
+    def bump_dev
+      dev ? with(dev: dev + 1) : with(patch: patch + 1, tiny: nil, dev: 1)
+    end
+
+    def finalize
+      with(tiny: nil, dev: nil)
+    end
+  end.freeze
+end

data/lib/gempilot/version.rb

@@ -1,3 +1,3 @@
 module Gempilot
-  VERSION = "0.3.0".freeze
+  VERSION = "0.3.1".freeze
 end

data/lib/gempilot/version_task.rb

@@ -50,7 +50,7 @@ module Gempilot
     end
 
     def define_bump_task(project)
-      desc "Bump version (patch default, or rake version:bump[minor])"
+      desc "Bump version (patch default; segments: major, minor, patch, tiny, dev)"
       task :bump, [:segment] do |_t, args|
         segment = (args[:segment] || :patch).to_sym
         old_version = project.version

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gempilot
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - David Gillis
@@ -72,6 +72,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".claude/memory/be-decisive-not-menus.md"
+- ".claude/memory/flagship-shared-rubocop-config-state.md"
 - ".claude/skills/using-command-kit/SKILL.md"
 - ".claude/skills/using-command-kit/cli-example.rb"
 - ".claude/skills/using-command-kit/generator-pattern.rb"
@@ -107,7 +109,9 @@ files:
 - data/templates/new/.keep
 - data/templates/new/command.rb.erb
 - docs/superpowers/plans/2026-07-20-release-task-hierarchy.md
+- docs/superpowers/plans/2026-08-09-dev-version-bump.md
 - docs/superpowers/specs/2026-07-20-release-task-hierarchy-design.md
+- docs/superpowers/specs/2026-08-09-dev-version-bump-design.md
 - exe/gempilot
 - issues.rec
 - lib/core_ext/string/inflection_methods.rb
@@ -130,6 +134,7 @@ files:
 - lib/gempilot/project.rb
 - lib/gempilot/project/version.rb
 - lib/gempilot/release_tasks.rb
+- lib/gempilot/segmented_version.rb
 - lib/gempilot/strict_shell.rb
 - lib/gempilot/version.rb
 - lib/gempilot/version_tag.rb
@@ -156,7 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.18
 specification_version: 4
 summary: A toolkit for creating, managing, and releasing your own rubygems
 test_files: []