lcp 0.1.0 → 0.2.0

data/lib/generators/lcp_ruby/claude_skills_generator.rb

@@ -5,41 +5,45 @@ require "lcp_ruby/skills_installer"
 
 module LcpRuby
   module Generators
-    # Installs LCP-specific Claude Code skills (`.claude/skills/lcp-*`) into the
-    # host application by copying them from the gem's bundled `.claude/skills/`.
+    # Legacy skills-only in-app entry. Installs LCP-specific AI authoring skills
+    # into all supported agent skill directories by copying them from the gem's
+    # bundled `.claude/skills/` source.
     # Re-running refreshes the skills to the version shipped with the currently
     # installed gem (useful after `bundle update lcp`) and prunes any `lcp-*`
     # skills the gem no longer ships. Non-`lcp-*` skills are never touched.
     #
-    # This is the skills-only in-app entry; `lcp_ruby:agent_setup` composes the
-    # same `SkillsInstaller` and additionally writes the CLAUDE.md/AGENTS.md
-    # entrypoint. Both call the installer directly (no generator-calls-generator).
+    # This is the skills-only in-app entry; `lcp_ruby:agent_setup` uses the same
+    # targets and additionally writes the CLAUDE.md/AGENTS.md entrypoint. Both
+    # call the installer directly (no generator-calls-generator).
     class ClaudeSkillsGenerator < Rails::Generators::Base
-      desc "Installs LCP Ruby Claude Code skills into .claude/skills/"
+      desc "Installs LCP Ruby AI agent skills into .claude/skills/ and .codex/skills/"
 
       def install_skills
-        @result = LcpRuby::SkillsInstaller.new(
-          target: File.join(destination_root, ".claude", "skills")
-        ).call
+        @results = {}
+        LcpRuby::SkillsInstaller.agent_skill_targets(root: destination_root).each do |agent, target|
+          result = LcpRuby::SkillsInstaller.new(target: target).call
+          @results[agent] = result
 
-        @result.created.each { |n| say_status :create, ".claude/skills/#{n}", :green }
-        @result.updated.each { |n| say_status :update, ".claude/skills/#{n}", :yellow }
-        @result.removed.each { |n| say_status :remove, ".claude/skills/#{n}", :red }
+          relative_target = File.join(LcpRuby::SkillsInstaller::AGENT_DIRECTORIES.fetch(agent), "skills")
+          result.created.each { |n| say_status :create, "#{relative_target}/#{n}", :green }
+          result.updated.each { |n| say_status :update, "#{relative_target}/#{n}", :yellow }
+          result.removed.each { |n| say_status :remove, "#{relative_target}/#{n}", :red }
+        end
       end
 
       def show_post_install_message
-        return if @result.nil? || !@result.any_changes?
+        return if @results.nil? || @results.values.none?(&:any_changes?)
 
-        installed = (@result.created + @result.updated).sort
+        installed = @results.values.flat_map { |result| result.created + result.updated }.uniq.sort
         say ""
-        say "Installed #{installed.size} LCP Ruby Claude Code skill(s):", :green
+        say "Installed #{installed.size} LCP Ruby AI agent skill(s):", :green
         installed.each { |n| say "  - #{n}" }
         say ""
-        say "Skills auto-trigger in Claude Code based on context (description keywords)."
-        say "List available skills via /skills inside Claude Code."
+        say "Skills auto-trigger in Claude Code and Codex based on context (description keywords)."
+        say "List available skills via /skills inside Claude Code or the Codex skills list."
         say ""
-        say "Refresh after `bundle update lcp`:"
-        say "  bin/rails generate lcp_ruby:claude_skills"
+        say "Preferred refresh after `bundle update lcp`:"
+        say "  bin/rails generate lcp_ruby:agent_setup"
         say ""
       end
     end

data/lib/generators/lcp_ruby/install_generator.rb

@@ -13,11 +13,45 @@ module LcpRuby
       desc "Sets up LCP Ruby in an existing Rails application"
 
       class_option :skip_sample, type: :boolean, default: false,
-        desc: "Skip creating sample item model"
+        desc: "Skip the sample `item` model + presenter + permissions + view group. Default: create them — a Hello-World scaffold so a fresh install has something to click at /items. Each generated file carries a DELETE ME header pointing at all four siblings."
+
+      # Header injected into each sample file (DSL + YAML both use `#` for
+      # comments, so one literal works for both formats). DslToYaml strips
+      # in-source comments during conversion, so we prepend after copy via
+      # `prepend_sample_header!` rather than embedding in the template.
+      SAMPLE_HEADER = <<~HEADER
+        # DELETE ME — sample scaffold for first-day discovery.
+        # `lcp_ruby:install` (and `lcp new` without `--skip-sample`) seeds
+        # this `item` entity so a fresh install has something to click at
+        # /items. Once you've added your own entities via
+        # `rails g lcp_ruby:entity`, delete all four sample files:
+        #   config/lcp_ruby/models/item.{rb,yml}
+        #   config/lcp_ruby/presenters/items.{rb,yml}
+        #   config/lcp_ruby/permissions/item.yml
+        #   config/lcp_ruby/views/items.{rb,yml}
+        # ...and remove `- view_group: items` from config/lcp_ruby/menu.yml.
+
+      HEADER
 
       class_option :active_storage, type: :boolean, default: true,
         desc: "Install Active Storage migrations (idempotent — skipped if already present)"
 
+      class_option :skip_asset_pipeline, type: :boolean, default: false,
+        desc: "Skip the Sprockets-compatibility shim (don't add `sprockets-rails` or create app/assets/config/manifest.js). " \
+              "Default: install. Only opt out if you've wired your own ESM bundler — LCP's JS won't load without one or the other."
+
+      # Sprockets manifest entries required for LCP's JS + CSS to be
+      # served by `javascript_include_tag` / `stylesheet_link_tag`. Used by
+      # `install_asset_pipeline_compat` (this generator) and mirrored in
+      # the engine's `check_asset_pipeline_compat!` error message — keep
+      # the two in sync.
+      SPROCKETS_MANIFEST_LINKS = [
+        "//= link lcp_ruby/application.js",
+        "//= link lcp_ruby/application.css",
+        "//= link lcp_ruby/tom-select.css",
+        "//= link lcp_ruby/tom-select.complete.min.js"
+      ].freeze
+
       class_option :menu_layout, type: :string, default: "both", enum: %w[top sidebar both],
         desc: "Menu layout sections to seed (top, sidebar, or both — default: both). " \
               "Seeds `# lcp:menu <section>` insertion markers for `rails g lcp_ruby:entity --menu=...`."
@@ -63,6 +97,24 @@ module LcpRuby
         route 'mount LcpRuby::Engine => "/"'
       end
 
+      # Sprockets compatibility shim (audit #16). Rails 8 ships Propshaft
+      # by default, which doesn't understand the `//= require` directives
+      # LCP's JS bundle uses. Without this shim, the layout's `<script>`
+      # tags either don't render (the old `respond_to?(:assets)` gate) or
+      # render but 404 — both present as "top nav invisible, no JS errors,
+      # no console output." The engine's boot check (`check_asset_pipeline_compat!`)
+      # raises if Propshaft is loaded without sprockets-rails; this method
+      # is the one-shot fix for that error.
+      #
+      # Idempotent: skips Gemfile insertion if the gem line already exists;
+      # appends only missing link directives to an existing manifest.js.
+      def install_asset_pipeline_compat
+        return if options[:skip_asset_pipeline]
+
+        add_sprockets_rails_to_gemfile!
+        ensure_sprockets_manifest!
+      end
+
       def create_directory_structure
         %w[models presenters permissions views].each do |dir|
           empty_directory "config/lcp_ruby/#{dir}"
@@ -75,6 +127,7 @@ module LcpRuby
         copy_dsl_or_yaml "model.rb",
           dsl_target: "config/lcp_ruby/models/item.rb",
           yaml_target: "config/lcp_ruby/models/item.yml"
+        prepend_sample_header!(yaml_format? ? "config/lcp_ruby/models/item.yml" : "config/lcp_ruby/models/item.rb")
       end
 
       def create_sample_presenter
@@ -83,12 +136,14 @@ module LcpRuby
         copy_dsl_or_yaml "presenter.rb",
           dsl_target: "config/lcp_ruby/presenters/items.rb",
           yaml_target: "config/lcp_ruby/presenters/items.yml"
+        prepend_sample_header!(yaml_format? ? "config/lcp_ruby/presenters/items.yml" : "config/lcp_ruby/presenters/items.rb")
       end
 
       def create_sample_permissions
         return if options[:skip_sample]
 
         template "permissions.yml", "config/lcp_ruby/permissions/item.yml"
+        prepend_sample_header!("config/lcp_ruby/permissions/item.yml")
       end
 
       def create_sample_view_group
@@ -97,6 +152,7 @@ module LcpRuby
         copy_dsl_or_yaml "view_group.rb",
           dsl_target: "config/lcp_ruby/views/items.rb",
           yaml_target: "config/lcp_ruby/views/items.yml"
+        prepend_sample_header!(yaml_format? ? "config/lcp_ruby/views/items.yml" : "config/lcp_ruby/views/items.rb")
       end
 
       def create_default_permissions
@@ -210,6 +266,58 @@ module LcpRuby
         RUBY
       end
 
+      # When the Sprockets compatibility shim is skipped, the engine's boot
+      # check would otherwise raise LcpRuby::AssetPipelineError on the next
+      # non-generator boot. Write the matching opt-out so the documented
+      # `--skip-asset-pipeline` flag yields a bootable app.
+      #
+      # MUST stay a separate step from `create_initializer` (which early-returns
+      # when the initializer already exists): on a re-run or install over a
+      # pre-existing initializer, the opt-out has to be applied regardless of
+      # whether the file was freshly created — otherwise the flag silently
+      # no-ops and the app won't boot. Idempotent: skips when the line is
+      # already present.
+      def configure_skip_asset_pipeline
+        return unless options[:skip_asset_pipeline]
+
+        initializer_path = "config/initializers/lcp_ruby.rb"
+        full_path = File.join(destination_root, initializer_path)
+        unless File.exist?(full_path)
+          say_status :skip, "skip_asset_pipeline_check (no #{initializer_path})", :yellow
+          return
+        end
+
+        content = File.read(full_path)
+        return if content.include?("skip_asset_pipeline_check")
+
+        # Match the configure block (both `do |x|` and brace `{ |x|` forms, the
+        # latter is what the engine's AssetPipelineError message suggests) and
+        # CAPTURE its block-variable name so the injected line targets the host's
+        # actual var (`config`, `c`, …) — a hardcoded `config.` would NameError
+        # at boot on a `|c|` initializer. Not anchored to a trailing newline, so
+        # a `do |config| # comment` line still matches.
+        match = content.match(/LcpRuby\.configure\s*(?:do|\{)\s*\|\s*(\w+)\s*\|/)
+        unless match
+          say_status :warn,
+            "could not anchor skip_asset_pipeline_check in #{initializer_path}; " \
+            "add `config.skip_asset_pipeline_check = true` inside the LcpRuby.configure block manually",
+            :yellow
+          return
+        end
+
+        var = match[1]
+        optout = <<~RUBY.indent(2)
+          # --skip-asset-pipeline was passed: the Sprockets compatibility shim
+          # is NOT installed, so the boot-time asset-pipeline check is opted
+          # out too (otherwise the engine raises LcpRuby::AssetPipelineError).
+          # Only correct if you've wired your own JS bundler (esbuild,
+          # importmap with a custom pin map, jsbundling, etc.).
+          #{var}.skip_asset_pipeline_check = true
+        RUBY
+
+        inject_into_file initializer_path, "\n#{optout}", after: match[0]
+      end
+
       def add_current_user_helper
         controller_path = "app/controllers/application_controller.rb"
         full_path = File.join(destination_root, controller_path)
@@ -260,6 +368,62 @@ module LcpRuby
         def invoke_active_storage_install!
           rails_command "active_storage:install", abort_on_failure: false
         end
+
+        # Thor's `prepend_to_file` is idempotent on string match but we
+        # also want to be no-op on rerun where the file was overwritten
+        # by `template`. Cheapest guard: skip when the header is already
+        # present at the top of the file.
+        def prepend_sample_header!(relative_path)
+          full_path = File.join(destination_root, relative_path)
+          return unless File.exist?(full_path)
+          return if File.read(full_path).start_with?("# DELETE ME")
+          prepend_to_file relative_path, SAMPLE_HEADER
+        end
+
+        # Idempotent Gemfile insertion. `gem "sprockets-rails"` matches
+        # any quote style or version constraint so re-runs don't duplicate.
+        def add_sprockets_rails_to_gemfile!
+          gemfile_path = File.join(destination_root, "Gemfile")
+          unless File.exist?(gemfile_path)
+            say_status :skip, "sprockets-rails (no Gemfile — manual install required)", :yellow
+            return
+          end
+
+          if File.read(gemfile_path).match?(/^\s*gem\s+["']sprockets-rails["']/)
+            say_status :identical, "Gemfile already has sprockets-rails"
+            return
+          end
+
+          gem "sprockets-rails"
+        end
+
+        # Creates or updates `app/assets/config/manifest.js`. If the file
+        # exists, only the missing `//= link` directives are appended —
+        # idempotent across re-runs and friendly to hosts that already
+        # have host-specific entries (e.g. `Chart.bundle.js` for charts).
+        def ensure_sprockets_manifest!
+          manifest_path = "app/assets/config/manifest.js"
+          full_path = File.join(destination_root, manifest_path)
+
+          if File.exist?(full_path)
+            existing = File.read(full_path)
+            missing = SPROCKETS_MANIFEST_LINKS.reject { |line| existing.include?(line) }
+            if missing.empty?
+              say_status :identical, manifest_path
+            else
+              append_to_file manifest_path, "\n# Added by lcp_ruby:install\n#{missing.join("\n")}\n"
+            end
+          else
+            create_file manifest_path, <<~MANIFEST
+              # LCP Ruby asset manifest (audit #16).
+              # `//= link` directives tell Sprockets to precompile + serve
+              # the listed files. The engine's JS bundle (~50 files) and
+              # CSS bundle are the load-bearing entries — without them
+              # the top nav, row-click, and form widgets are inert.
+              #{SPROCKETS_MANIFEST_LINKS.join("\n")}
+            MANIFEST
+          end
+        end
       end
 
       # Agent affordances: copies the lcp-* skills and writes CLAUDE.md/AGENTS.md
@@ -277,7 +441,7 @@ module LcpRuby
         say "LCP Ruby installed!", :green
         say ""
         unless options[:skip_sample]
-          say "Sample files:"
+          say "Sample files (each carries a 'DELETE ME' header — remove when you add your own entities):"
           say "  config/lcp_ruby/models/item.#{format_extension}"
           say "  config/lcp_ruby/presenters/items.#{format_extension}"
           say "  config/lcp_ruby/permissions/item.yml"
@@ -292,7 +456,11 @@ module LcpRuby
         say "Next steps:"
         say "  1. rails db:prepare"
         say "  2. rails s"
-        say "  3. Visit http://localhost:3000/items"
+        if options[:skip_sample]
+          say "  3. Add your first entity: rails generate lcp_ruby:entity Foo name:string"
+        else
+          say "  3. Visit http://localhost:3000/items"
+        end
         say ""
         say "Add features with generators:"
         say "  rails generate lcp_ruby:install_auth      # Devise authentication"

data/lib/generators/lcp_ruby/templates/agent_setup/agents_md.md

@@ -1,3 +1,4 @@
 This project uses **LCP Ruby**. See `CLAUDE.md` for orientation (project
 layout, skills, docs, validation) — the same guidance applies to all agents.
-For authoring patterns, also read `.claude/skills/lcp-*/SKILL.md`.
+For authoring patterns, use the installed skills in `.codex/skills/lcp-*` or
+`.claude/skills/lcp-*`.

data/lib/generators/lcp_ruby/templates/agent_setup/claude_md.md

@@ -2,8 +2,9 @@ This is an **LCP Ruby** project (low-code platform). App behavior is metadata
 under `config/lcp_ruby/`: `models/` (data), `presenters/` (UI),
 `permissions/` (roles).
 
-- **Authoring guidance:** skills in `.claude/skills/lcp-*` (auto-trigger in
-  Claude Code; other agents can read the `SKILL.md` files directly).
+- **Authoring guidance:** skills in `.claude/skills/lcp-*` for Claude Code and
+  `.codex/skills/lcp-*` for Codex. Both directories contain the same `SKILL.md`
+  guidance and auto-trigger in their respective agent.
 - **Reference docs:** in-app `bundle exec rake lcp_ruby:docs` (matches the
   bundled gem version), or `lcp docs path` globally — start at `docs/README.md`.
   When a skill or doc says `docs/X`, resolve it under that path.

data/lib/generators/lcp_ruby/templates/install/menu.yml.tt

@@ -6,7 +6,9 @@ menu:
 <% if %w[top both].include?(options[:menu_layout]) -%>
   # >>> LCP_USER_MENU_BLOCK (rewritten by lcp_ruby:install_auth) <<<
   top_menu:
+<% unless options[:skip_sample] -%>
     - view_group: items
+<% end -%>
     # lcp:menu top  # entity generator marker - do not edit/delete
 
   # Uncomment when adding authentication, or run
@@ -62,7 +64,9 @@ menu:
 <% end -%>
 <% if options[:menu_layout] == "sidebar" -%>
   sidebar_menu:
+<% unless options[:skip_sample] -%>
     - view_group: items
+<% end -%>
     # lcp:menu sidebar  # entity generator marker - do not edit/delete
 <% elsif options[:menu_layout] == "both" -%>
 

data/lib/generators/lcp_ruby/templates/monitoring/page.yml

@@ -2,6 +2,11 @@ page:
   name: monitoring_dashboard
   slug: monitoring
   layout: grid
+  # Operator-facing dashboard (error counts, metrics, recent errors).
+  # Restricted to admin by default; relax this when other roles need read access.
+  visible_when:
+    service: current_user_role
+    params: { in: [admin] }
 
   zones:
     - name: models_loaded

data/lib/lcp_ruby/app_template.rb

@@ -11,6 +11,8 @@
 #   LCP_TIMEZONE           - default timezone (default: "UTC")
 #   LCP_LOCALE             - default locale (default: "en")
 #   LCP_MENU_LAYOUT        - "top", "sidebar", or "both" (default: "both")
+#   LCP_SKIP_SAMPLE        - "1" to skip the Hello-World item model, "0" (default) to scaffold it
+#   LCP_SKIP_ASSET_PIPELINE - "1" to skip Sprockets compat shim (only for ESM-bundler users), "0" (default) to install it
 
 require "json"
 
@@ -22,6 +24,8 @@ gem_source         = ENV.fetch("LCP_GEM_SOURCE", "rubygems")
 timezone           = ENV.fetch("LCP_TIMEZONE", "UTC")
 locale             = ENV.fetch("LCP_LOCALE", "en")
 menu_layout        = ENV.fetch("LCP_MENU_LAYOUT", "both")
+skip_sample        = ENV.fetch("LCP_SKIP_SAMPLE", "0") == "1"
+skip_asset_pipeline = ENV.fetch("LCP_SKIP_ASSET_PIPELINE", "0") == "1"
 
 # Add lcp gem
 case gem_source
@@ -35,6 +39,34 @@ else
   gem "lcp"
 end
 
+# Sprockets compatibility shim (audit #16). Rails 8 ships Propshaft by
+# default; LCP's JS uses Sprockets `//= require` directives that Propshaft
+# can't parse, so without sprockets-rails the engine's nav + Stimulus
+# controllers are silently inert. Add the gem at template-level so it's
+# bundled before `after_bundle`'s `rails generate lcp_ruby:install` boots
+# Rails (the install generator's `install_asset_pipeline_compat` step
+# would otherwise hit the engine's loud boot check before getting to add
+# the gem). The install generator's logic is still the source of truth —
+# this hoist just sidesteps the chicken-and-egg.
+gem "sprockets-rails" unless skip_asset_pipeline
+
+# Create app/assets/config/manifest.js at template level too. sprockets-rails
+# 3.5+ RAISES (ManifestNeededError) the moment its railtie loads without a
+# manifest, and Rails 8's `rails new` boots the app (solid_cache:install, etc.)
+# in `after_bundle` BEFORE `lcp_ruby:install` would create it — so the manifest
+# must exist before any boot. `lcp_ruby:install`'s `ensure_sprockets_manifest!`
+# is idempotent (only appends missing `//= link` lines), so this is the
+# source-of-truth's early twin, not a fork.
+unless skip_asset_pipeline
+  create_file "app/assets/config/manifest.js", <<~MANIFEST
+    //= link_directory ../stylesheets .css
+    //= link lcp_ruby/application.js
+    //= link lcp_ruby/application.css
+    //= link lcp_ruby/tom-select.css
+    //= link lcp_ruby/tom-select.complete.min.js
+  MANIFEST
+end
+
 # Generators that accept --format option. Source of truth lives in
 # `LcpRuby::Generators::FeatureRegistry` once the gem is loaded
 # (`after_bundle`); this list mirrors the wizard's curated set.
@@ -89,10 +121,14 @@ after_bundle do
   # abort_on_failure behaviour (no `inline:`).
   # Core install also sets up agent affordances at the end (skills +
   # CLAUDE.md/AGENTS.md via `lcp_ruby:agent_setup`) — passive, no runtime impact.
-  generate "lcp_ruby:install",
+  install_args = [
     "--format=#{format}",
     "--menu-layout=#{menu_layout}",
     "--locale=#{locale}"
+  ]
+  install_args << "--skip-sample" if skip_sample
+  install_args << "--skip-asset-pipeline" if skip_asset_pipeline
+  generate "lcp_ruby:install", *install_args
 
   # Build manifest header before the feature loop so even an empty preset
   # produces a manifest the doctor can introspect.

data/lib/lcp_ruby/array_query.rb

@@ -1,7 +1,9 @@
 module LcpRuby
   # DB-portable query helpers for array fields.
-  # Uses native PG array operators (@>, &&, <@) on PostgreSQL
-  # and json_each() subqueries on SQLite.
+  # Uses native PG array operators (@>, &&, <@) on PostgreSQL, a json_each()
+  # subquery on SQLite, and a JSON_TABLE() row source on MySQL/MariaDB (which
+  # has no json_each). Both non-PG backends expose each element as `je.value`,
+  # so the conditions below are shared.
   class ArrayQuery
     class << self
       # Records where the array field contains ALL of the given values.
@@ -15,7 +17,7 @@ module LcpRuby
         condition = if LcpRuby.postgresql?
           "#{col} @> #{pg_array_literal(values, c, item_type)}"
         else
-          "(SELECT COUNT(DISTINCT je.value) FROM json_each(#{col}) je " \
+          "(SELECT COUNT(DISTINCT je.value) FROM #{json_elements(col)} " \
             "WHERE je.value IN (#{quoted_values(values, c)})) = #{values.size}"
         end
 
@@ -33,7 +35,7 @@ module LcpRuby
         condition = if LcpRuby.postgresql?
           "#{col} && #{pg_array_literal(values, c, item_type)}"
         else
-          "EXISTS (SELECT 1 FROM json_each(#{col}) je " \
+          "EXISTS (SELECT 1 FROM #{json_elements(col)} " \
             "WHERE je.value IN (#{quoted_values(values, c)}))"
         end
 
@@ -50,16 +52,14 @@ module LcpRuby
 
         if values.empty?
           return scope.where(Arel.sql(
-            LcpRuby.postgresql? ?
-              "#{col} = '{}'" :
-              "json_array_length(#{col}) = 0"
+            LcpRuby.postgresql? ? "#{col} = '{}'" : "#{json_length(col)} = 0"
           ))
         end
 
         condition = if LcpRuby.postgresql?
           "#{col} <@ #{pg_array_literal(values, c, item_type)}"
         else
-          "NOT EXISTS (SELECT 1 FROM json_each(#{col}) je " \
+          "NOT EXISTS (SELECT 1 FROM #{json_elements(col)} " \
             "WHERE je.value NOT IN (#{quoted_values(values, c)}))"
         end
 
@@ -74,7 +74,7 @@ module LcpRuby
         if LcpRuby.postgresql?
           "COALESCE(array_length(#{col}, 1), 0)"
         else
-          "json_array_length(#{col})"
+          json_length(col)
         end
       end
 
@@ -88,13 +88,36 @@ module LcpRuby
           "EXISTS (SELECT 1 FROM unnest(#{col}) item " \
             "WHERE item ILIKE #{quoted_query})"
         else
-          "EXISTS (SELECT 1 FROM json_each(#{col}) je " \
+          "EXISTS (SELECT 1 FROM #{json_elements(col)} " \
             "WHERE je.value LIKE #{quoted_query})"
         end
       end
 
       private
 
+      # Row source aliased `je` exposing each array element as a TEXT `je.value`,
+      # so the conditions can compare it against the quoted string literals from
+      # quoted_values regardless of the element's JSON type.
+      #
+      # MySQL/MariaDB has no json_each — JSON_TABLE with a LONGTEXT column yields
+      # text already (LONGTEXT, not a sized VARCHAR, so elements > 255 chars such
+      # as URLs aren't silently truncated). SQLite's json_each preserves the JSON
+      # type, so a numeric element comes back as an INTEGER/REAL that never equals
+      # the string literal `'1'` — wrap it in a derived table that CASTs to TEXT
+      # (TEXT is not a valid MySQL CAST target, hence the per-adapter split).
+      def json_elements(col)
+        if LcpRuby.mysql?
+          "JSON_TABLE(#{col}, '$[*]' COLUMNS(value LONGTEXT PATH '$')) je"
+        else
+          "(SELECT CAST(value AS TEXT) AS value FROM json_each(#{col})) je"
+        end
+      end
+
+      # Number of elements in the JSON array column.
+      def json_length(col)
+        LcpRuby.mysql? ? "JSON_LENGTH(#{col})" : "json_array_length(#{col})"
+      end
+
       def connection
         ActiveRecord::Base.connection
       end

data/lib/lcp_ruby/cli/new_command.rb

@@ -9,7 +9,7 @@ module LcpRuby
   module CLI
     class NewCommand
       MINIMUM_RAILS_VERSION = "8.1"
-      MINIMUM_RUBY_VERSION = "3.1"
+      MINIMUM_RUBY_VERSION = "3.2"
 
       DATABASES = %w[sqlite3 postgresql mysql2].freeze
 
@@ -134,7 +134,10 @@ module LcpRuby
       end
 
       def check_rails_version!
-        version_output = `rails --version 2>/dev/null`.strip
+        # File::NULL (not a literal /dev/null) so the stderr redirect is valid
+        # on Windows cmd.exe too — otherwise the shell-out fails and this reads
+        # as "rails not found", aborting `lcp new` on Windows.
+        version_output = `rails --version 2>#{File::NULL}`.strip
         if version_output.empty?
           abort "Error: 'rails' command not found. Install Rails #{MINIMUM_RAILS_VERSION}+:\n  gem install rails"
         end
@@ -387,7 +390,9 @@ module LcpRuby
           "LCP_GEM_SOURCE" => @gem_source,
           "LCP_TIMEZONE" => @timezone,
           "LCP_LOCALE" => @locale,
-          "LCP_MENU_LAYOUT" => @menu_layout
+          "LCP_MENU_LAYOUT" => @menu_layout,
+          "LCP_SKIP_SAMPLE" => @options[:skip_sample] ? "1" : "0",
+          "LCP_SKIP_ASSET_PIPELINE" => @options[:skip_asset_pipeline] ? "1" : "0"
         }
 
         # Action Text is installed by default — `:rich_text` fields are a
@@ -436,7 +441,7 @@ module LcpRuby
         say ""
         say "Application created successfully!", :green
         say ""
-        say "AI agents are set up: CLAUDE.md + .claude/skills/lcp-* are ready.", :green
+        say "AI agents are set up: CLAUDE.md + .claude/skills and .codex/skills are ready.", :green
         say "  Reference docs: bundle exec rake lcp_ruby:docs"
         say "  Validate config: bundle exec rake lcp_ruby:validate"
         say ""