rubyn-code 0.5.0 → 0.7.0

data/skills/rubyn_self_test.md

@@ -63,30 +63,113 @@ Score: 18/22 (82%) — 4 failures
 #### File Cache
 - Read `lib/rubyn_code/version.rb` twice. PASS if both reads succeed (cache should serve the second).
 
-#### Output Compressor — Head/Tail Strategy
-- Run `bash` with `seq 1 5000` (generates 5,000 lines — well over the bash threshold of 4,000 chars). PASS if the result contains "lines omitted" or is significantly shorter than 5,000 lines. This proves the head_tail compressor is working.
+#### Output Compressor — All Strategies (direct)
 
-#### Output Compressor — Spec Summary Strategy
-- Run `bash` with `cd <project_root> && bundle exec rspec spec/rubyn_code/tools/base_spec.rb --format documentation 2>&1`. This produces multi-line RSpec output. PASS if the result you receive is shorter than the full verbose output — specifically check if passing specs got compressed to a summary line like "N examples, 0 failures" instead of listing every example.
+> **Why this is a direct call, not a tool observation.** Earlier versions of this
+> test ran `seq 1 5000`, a big `grep`, etc. through the agent's own tools and
+> hoped the compressor would visibly truncate the result. That is unreliable:
+> whether a given tool invocation is routed through the compressor gate (and at
+> what threshold) depends on the execution path, so the agent often received
+> already-handled output and scored a false FAIL even though the compressor was
+> fine. Instead, drive `OutputCompressor#compress(tool_name, raw_output)`
+> **directly** with inputs crafted to exceed each strategy's threshold, and
+> assert on the marker in the returned string. This is deterministic and matches
+> how the unit specs exercise it.
 
-#### Output Compressor — Grep Top Matches
-- Run `grep` searching for `def ` across all of `lib/`. This will match hundreds of method definitions. PASS if the result contains "matches omitted" or shows only a subset of results (the compressor limits to top N matches).
+- **All strategies**: `bash` with the script below. PASS for each strategy whose line says `PASS`. Report the final `COMPRESSION: N/5 strategies active` line in the scorecard.
 
-#### Output Compressor — Glob Tree Collapse
-- Run `glob` for `**/*.rb` across the entire project. With 170+ files this should exceed the glob threshold. PASS if the result shows directory summaries like `app/models/ (N files)` instead of listing every individual file path, OR if the result is significantly shorter than listing all 170+ paths individually.
+  ```bash
+  bundle exec ruby -e '
+    require_relative "lib/rubyn_code"
+    c = RubynCode::Tools::OutputCompressor
+
+    results = {}
+
+    # head_tail (bash, 1000-token threshold): >10 lines, well over 4000 chars
+    big = (1..5000).map { |i| "line #{i}" }.join("\n")
+    results["head_tail"] = c.new.compress("bash", big).include?("lines omitted")
+
+    # spec_summary (run_specs, 500-token threshold): verbose passing output
+    # collapses to just the "N examples, 0 failures" summary line
+    spec_out = (Array.new(200) { |i| "  passing example #{i} runs and returns ok value" }.join("\n")) +
+               "\n\n42 examples, 0 failures\n"
+    results["spec_summary"] = (c.new.compress("run_specs", spec_out).strip == "42 examples, 0 failures")
+
+    # top_matches (grep, 1000-token threshold): keeps top N, marks the rest
+    grep_out = (1..500).map { |i| "lib/file#{i}.rb:#{i}:  def method_number_#{i}(arg)" }.join("\n")
+    results["top_matches"] = c.new.compress("grep", grep_out).include?("matches omitted")
+
+    # tree (glob, 500-token threshold): collapses paths to "dir/ (N files)"
+    glob_out = (1..500).map { |i| "lib/rubyn_code/subdir#{i % 25}/some_file_name_#{i}.rb" }.join("\n")
+    results["tree"] = c.new.compress("glob", glob_out).include?("files)")
+
+    # relevant_hunks (git_diff, 2000-token threshold): keeps headers, truncates bodies
+    hunk = ->(f) { "diff --git a/#{f} b/#{f}\nindex 000..111 100644\n--- a/#{f}\n+++ b/#{f}\n" +
+                   (Array.new(100) { |i| "+ added source line number #{i}" }.join("\n")) + "\n" }
+    diff_out = (1..10).map { |i| hunk.call("file#{i}.rb") }.join
+    results["relevant_hunks"] = c.new.compress("git_diff", diff_out).include?("lines in this file omitted")
 
-#### Output Compressor — Diff Strategy
-- Run `bash` with `cd <project_root> && git log --oneline -1 --format=%H | xargs git diff HEAD~5..` (diff of last 5 commits). If the diff is large enough, the compressor should keep headers but truncate bodies. PASS if result contains diff headers. SKIP if diff is small enough to pass through uncompressed.
+    results.each { |k, v| puts "STRATEGY #{k}: #{v ? "PASS" : "FAIL"}" }
+    puts "COMPRESSION: #{results.values.count(true)}/5 strategies active"
+  '
+  ```
 
-#### Compression Stats
-- After running the above tests, note whether any output you received contained truncation markers like "lines omitted", "matches omitted", or "files)". Count how many of the 5 compression strategies actually triggered. Report: "N/5 compression strategies verified active".
+  Each strategy is scored independently (5 line items). A healthy build prints `COMPRESSION: 5/5 strategies active`.
 
 ### 7. Skills System
 - **load_skill**: Load any available skill (e.g., `classes`). PASS if content is returned.
 
 ### 8. Memory System
-- **memory_write**: Write a test memory: `category: "test", content: "self-test at #{Time.now}"`. PASS if no error.
-- **memory_search**: Search for `self-test`. PASS if the memory we just wrote is found.
+
+> **Use the real `Memory::Store` / `Memory::Search` API.** Both are constructed
+> as `.new(db, project_path:)` — the `project_path:` keyword is **required**, and
+> `db` must respond to `execute` / `query` / `transaction` (a raw
+> `SQLite3::Database` alone does **not** provide `query`, which `Search` needs).
+> The script below wraps an in-memory SQLite DB to satisfy that interface, exactly
+> as the specs' `setup_test_db` helper does. Writing the memory creates its own
+> table via `Store#ensure_tables`, so no migrations are needed.
+
+- **Round-trip**: `bash` with the script below. PASS if the final line is `MEMORY: PASS`.
+
+  ```bash
+  bundle exec ruby -e '
+    require_relative "lib/rubyn_code"
+    require "sqlite3"
+
+    # Minimal stand-in for RubynCode::DB::Connection (execute/query/transaction).
+    class SelfTestDB
+      def initialize(raw) = @raw = raw
+      def execute(sql, params = []) = @raw.execute(sql, params)
+      def query(sql, params = []) = @raw.execute(sql, params)
+      def transaction(&b) = @raw.transaction(&b)
+    end
+
+    raw = SQLite3::Database.new(":memory:")
+    raw.results_as_hash = true
+    db = SelfTestDB.new(raw)
+
+    project = "/self-test"
+    store  = RubynCode::Memory::Store.new(db, project_path: project)
+    search = RubynCode::Memory::Search.new(db, project_path: project)
+
+    token = "selftesttoken-marker-xyz"
+    store.write(content: "self-test memory #{token}")
+
+    found     = search.search(token).any? { |r| r.content.include?(token) }
+    recent_ok = search.recent(limit: 5).any? { |r| r.content.include?(token) }
+
+    if found && recent_ok
+      puts "MEMORY: PASS (write + search + recent all round-trip)"
+    elsif found
+      puts "MEMORY: PARTIAL (search works, recent did not return it)"
+    else
+      puts "MEMORY: FAIL (write succeeded but search did not return it)"
+    end
+  '
+  ```
+
+  The script writes a memory with a unique token, then confirms both
+  `Search#search` (LIKE query) and `Search#recent` return it.
 
 ### 9. Configuration
 - **bash**: Run `cat ~/.rubyn-code/config.yml`. PASS if file exists and contains `provider:`.
@@ -190,6 +273,231 @@ End-to-end exercise of the autoload pipeline against the real registry at `rubyn
   ```
   before the next response (the `📥` line appears only if the pack wasn't already installed). Do **not** count this as PASS/FAIL — just mention it in the scorecard so the user can verify the renderer side themselves.
 
+### 16. Teams System — Multi-Agent
+
+Run the following inline Ruby script with `bash`. It exercises the teammate manager, mailbox (including structured messaging), and agent registry in a single SQLite-backed round-trip. PASS if the final line is `ALL PASS`.
+
+  ```bash
+  bundle exec ruby -e '
+    require_relative "lib/rubyn_code"
+    require "sqlite3"
+
+    db = SQLite3::Database.new(":memory:")
+    db.results_as_hash = true
+
+    mailbox = RubynCode::Teams::Mailbox.new(db)
+    manager = RubynCode::Teams::Manager.new(db, mailbox: mailbox)
+    registry = RubynCode::Teams::AgentRegistry.new(manager: manager, mailbox: mailbox)
+
+    # 1. Spawn root + child teammates
+    root = manager.spawn(name: "lead", role: "coordinator")
+    child = manager.spawn(name: "coder", role: "developer", parent_agent_id: root.id)
+    raise "spawn failed" unless root.root? && !child.root?
+    puts "STEP spawn: PASS"
+
+    # 2. Parent-child tracking
+    kids = manager.children_of(root.id)
+    raise "children_of broken" unless kids.size == 1 && kids.first.name == "coder"
+    raise "roots broken" unless manager.roots.size == 1
+    tree = manager.agent_tree(root.id)
+    raise "tree broken" unless tree[:children].size == 1
+    puts "STEP lineage: PASS"
+
+    # 3. Structured messaging with correlation_id
+    corr_id = mailbox.send_structured(
+      from: "lead", to: "coder", type: "task",
+      data: { action: "write_tests", files: ["user.rb"] },
+      content: "Write tests for user.rb"
+    )
+    raise "send_structured returned nil" if corr_id.nil?
+
+    msgs = mailbox.read_inbox("coder")
+    raise "inbox empty" if msgs.empty?
+    msg = msgs.first
+    raise "missing data" unless msg[:data].is_a?(Hash) && msg[:data][:action] == "write_tests"
+    raise "missing correlation_id" unless msg[:correlation_id].is_a?(String)
+    puts "STEP structured_msg: PASS"
+
+    # 4. Correlation chain
+    mailbox.send(
+      from: "coder", to: "lead", content: "Done",
+      message_type: "result", correlation_id: msg[:correlation_id],
+      data: { status: "ok", tests: 5 }
+    )
+    chain = mailbox.find_by_correlation_id(msg[:correlation_id])
+    raise "correlation chain broken (#{chain.size})" unless chain.size == 2
+    puts "STEP correlation: PASS"
+
+    # 5. Agent discovery
+    manager.update_status("coder", "active")
+    snap = registry.snapshot
+    raise "snapshot broken" unless snap.size == 2
+    actives = registry.active
+    raise "active filter broken" unless actives.size == 1 && actives.first[:name] == "coder"
+    forest = registry.forest
+    raise "forest broken" unless forest.size == 1 && forest.first[:children].size == 1
+    lineage = registry.lineage(child.id)
+    raise "lineage broken" unless lineage.size == 1 && lineage.first.name == "lead"
+    report = registry.status_report
+    raise "status_report broken" unless report.include?("lead") && report.include?("coder")
+    puts "STEP discovery: PASS"
+
+    # 6. Cleanup + unread_count
+    raise "unread wrong" unless mailbox.unread_count("lead") == 1
+    mailbox.read_inbox("lead")
+    raise "read didnt clear" unless mailbox.unread_count("lead") == 0
+    manager.remove("coder")
+    manager.remove("lead")
+    raise "cleanup failed" unless manager.list.empty?
+    puts "STEP cleanup: PASS"
+
+    puts "ALL PASS"
+  '
+  ```
+
+  The script tests:
+  1. **Spawn** — root and child teammates with parent tracking
+  2. **Lineage** — `children_of`, `roots`, `agent_tree`
+  3. **Structured messaging** — `send_structured` with typed data payloads
+  4. **Correlation chains** — request/response pairing via `correlation_id`
+  5. **Agent discovery** — `snapshot`, `active`, `forest`, `lineage`, `status_report`
+  6. **Cleanup** — `unread_count`, `read_inbox`, `remove`
+
+  PASS criteria: all 6 `STEP` lines say PASS and the final line is `ALL PASS`.
+
+### 17. Recent Additions — Claude Code / Codex Parity
+
+Each feature below ships as its own PR; a check FAILs cleanly if that PR has
+not yet merged into the branch under test. Run the grep/spec checks — they are
+fast and need no API calls.
+
+#### 17a. `/goal` — work until a goal is met
+- **grep**: `class GoalHook` in `lib/rubyn_code/hooks/goal_hook.rb`. PASS if found.
+- **grep**: `:stop` in `lib/rubyn_code/hooks/runner.rb`. PASS if found (stop-hook gating wired).
+- **run_specs**: `bundle exec rspec spec/rubyn_code/hooks/goal_hook_spec.rb spec/rubyn_code/cli/commands/goal_spec.rb --format progress`. PASS if `0 failures`.
+
+#### 17b. `/loop` — repeat a prompt/command on an interval
+- **grep**: `class LoopRunner` in `lib/rubyn_code/cli/loop_runner.rb`. PASS if found.
+- **run_specs**: `bundle exec rspec spec/rubyn_code/cli/loop_runner_spec.rb spec/rubyn_code/cli/commands/loop_spec.rb --format progress`. PASS if `0 failures`.
+- **bash** (behavior): `bundle exec ruby -Ilib -rrubyn_code -e 'puts RubynCode::CLI::LoopRunner.parse_interval("5m")'`. PASS if output is `300`.
+
+#### 17c. `AGENTS.md` project instructions
+- **grep**: `AGENTS.md` in `lib/rubyn_code/agent/system_prompt_builder.rb`. PASS if found.
+- **run_specs**: `bundle exec rspec spec/rubyn_code/agent/system_prompt_builder_spec.rb --format progress`. PASS if `0 failures`.
+
+#### 17d. `@`-file mentions
+- **grep**: `class MentionExpander` in `lib/rubyn_code/cli/mention_expander.rb`. PASS if found.
+- **run_specs**: `bundle exec rspec spec/rubyn_code/cli/mention_expander_spec.rb --format progress`. PASS if `0 failures`.
+
+#### 17e. User-defined slash commands
+- **grep**: `module CustomLoader` in `lib/rubyn_code/cli/commands/custom_loader.rb`. PASS if found.
+- **run_specs**: `bundle exec rspec spec/rubyn_code/cli/commands/custom_loader_spec.rb spec/rubyn_code/cli/commands/command_template_spec.rb --format progress`. PASS if `0 failures`.
+
+#### 17f. Custom sub-agents + `/agents`
+- **grep**: `class Catalog` in `lib/rubyn_code/sub_agents/catalog.rb`. PASS if found.
+- **run_specs**: `bundle exec rspec spec/rubyn_code/sub_agents/catalog_spec.rb spec/rubyn_code/tools/spawn_agent_spec.rb --format progress`. PASS if `0 failures` (spawn_agent must still pass after the refactor).
+
+#### 17g. MCP resources & prompts
+- **grep**: `def supports_resources?` in `lib/rubyn_code/mcp/client.rb`. PASS if found.
+- **run_specs**: `bundle exec rspec spec/rubyn_code/mcp/client_spec.rb spec/rubyn_code/mcp/tool_bridge_spec.rb --format progress`. PASS if `0 failures`.
+
+#### 17h. `/rewind` — checkpoint & restore
+- **grep**: `class Manager` in `lib/rubyn_code/checkpoint/manager.rb`. PASS if found.
+- **run_specs**: `bundle exec rspec spec/rubyn_code/checkpoint --format progress`. PASS if `0 failures`.
+
+#### 17i. Learning export/import
+- **grep**: `module Porter` in `lib/rubyn_code/learning/porter.rb`. PASS if found.
+- **run_specs**: `bundle exec rspec spec/rubyn_code/learning/porter_spec.rb --format progress`. PASS if `0 failures`.
+- **bash** (round-trip): the script below exports instincts to a temp file and re-imports them into a fresh in-memory DB. PASS if the final line is `LEARNING ROUNDTRIP: PASS`.
+
+  ```bash
+  bundle exec ruby -Ilib -rrubyn_code -rsqlite3 -rtmpdir -e '
+    def db_with_instincts
+      raw = SQLite3::Database.new(":memory:"); raw.results_as_hash = true
+      raw.execute(File.read("db/migrations/010_create_instincts.sql").split(";").first + ";")
+      wrap = Object.new
+      wrap.define_singleton_method(:execute) { |sql, p = []| raw.execute(sql, p) }
+      wrap.define_singleton_method(:query)   { |sql, p = []| raw.execute(sql, p) }
+      wrap
+    end
+    src = db_with_instincts
+    src.execute("INSERT INTO instincts (id,project_path,pattern,context_tags,confidence,decay_rate,times_applied,times_helpful,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?,?)",
+                ["x","/p","prefer guard clauses","[]",0.8,0.05,1,1,"2026-01-01T00:00:00Z","2026-01-01T00:00:00Z"])
+    Dir.mktmpdir do |d|
+      f = File.join(d, "l.json")
+      RubynCode::Learning::Porter.export(db: src, path: f)
+      dst = db_with_instincts
+      res = RubynCode::Learning::Porter.import(db: dst, path: f)
+      ok = res[:imported] == 1 && dst.query("SELECT COUNT(*) AS n FROM instincts").first["n"] == 1
+      puts(ok ? "LEARNING ROUNDTRIP: PASS" : "LEARNING ROUNDTRIP: FAIL #{res.inspect}")
+    end
+  '
+  ```
+
+#### 17j. Command registry integrity (all new commands load + register)
+- **bash**: the script below boots the command registry exactly as the REPL does and asserts the new slash commands are present and unique. PASS if the final line is `COMMANDS: PASS`.
+
+  ```bash
+  bundle exec ruby -Ilib -rrubyn_code -e '
+    reg = RubynCode::CLI::Commands::Registry.new
+    [RubynCode::CLI::Commands::Goal, RubynCode::CLI::Commands::Loop,
+     RubynCode::CLI::Commands::Agents, RubynCode::CLI::Commands::Rewind,
+     RubynCode::CLI::Commands::Learning].each { |c| reg.register(c) }
+    want = %w[/goal /loop /agents /rewind /learning]
+    missing = want.reject { |n| reg.known?(n) }
+    puts(missing.empty? ? "COMMANDS: PASS" : "COMMANDS: FAIL missing #{missing.inspect}")
+  '
+  ```
+
+### 18. Chisel — Minimal-Code Enforcement (opt-in)
+
+Chisel is rubyn-code's "write the minimum that works" layer. It is **off by
+default** and only changes the agent once a user turns it on (`/chisel full` or
+`chisel_mode` in config). These checks prove the engine resolves modes, injects
+its ruleset only when enabled, never chisels away the safety floor, and that the
+debt scanner, inspection prompts, and all five slash commands are wired up — all
+deterministic, no API calls.
+
+The deterministic target is a committed, deliberately over-engineered fixture,
+`skills/self_test/fixtures/chisel_sample.rb`. Chisel scans it and must return the
+**same three `chisel:` markers every time** (and ignore the two decoys). That is
+what makes this check repeatable rather than a one-off tmpdir.
+
+- **grep** (prompt integration): `append_chisel_ruleset` in `lib/rubyn_code/agent/system_prompt_builder.rb`. PASS if found (confirms the ruleset reaches the system prompt).
+- **run_specs**: `bundle exec rspec spec/rubyn_code/chisel_spec.rb spec/rubyn_code/chisel spec/rubyn_code/cli/commands/chisel_spec.rb spec/rubyn_code/cli/commands/chisel_review_spec.rb spec/rubyn_code/cli/commands/chisel_audit_spec.rb spec/rubyn_code/cli/commands/chisel_debt_spec.rb spec/rubyn_code/cli/commands/chisel_gain_spec.rb --format progress`. PASS if output contains `0 failures`. (Includes `self_test_fixture_spec.rb`, which guards the fixture's exact scan result.)
+- **Smoke run against the fixture**: `bash` runs the committed runner — no inline script to keep in sync:
+
+  ```bash
+  bundle exec ruby skills/self_test/chisel_smoke.rb
+  ```
+
+  It scores four areas on their own line and exits non-zero on any failure:
+
+  ```
+  CHISEL debt: PASS
+  CHISEL engine: PASS
+  CHISEL inspection: PASS
+  CHISEL commands: PASS
+  CHISEL: PASS
+  ```
+
+  - **debt** — scanning the fixture returns exactly its three planted markers
+    (file/line/note), with the string-literal and trailing-comment decoys ignored.
+  - **engine** — `off` injects nothing; `lite`/`full`/`ultra` layer the right
+    addenda and always keep the safety floor; a garbage mode never crashes or
+    leaks through. Driven via `RUBYN_CHISEL_MODE`, independent of this machine's
+    `chisel_mode` config.
+  - **inspection** — `:diff` and `:repo` prompts assemble a String carrying the
+    ladder + safety floor; an unknown scope raises instead of emitting junk.
+  - **commands** — all five (`/chisel`, `/chisel-review`, `/chisel-audit`,
+    `/chisel-debt`, `/chisel-gain`) register and resolve.
+
+  Score each `CHISEL <area>` line independently (4 line items). PASS criteria:
+  all four areas PASS and the final line is `CHISEL: PASS`.
+
+  You can also point Chisel at the fixture by hand to see the consistent result
+  directly: `bundle exec ruby -Ilib -rrubyn_code -e 'RubynCode::Chisel::Debt.scan("skills/self_test/fixtures").each { |i| puts "#{i.file}:#{i.line} — #{i.note}" }'`.
+
 ## Scoring
 
 Count total PASS results out of total tests run. Report the percentage.

data/skills/self_test/chisel_smoke.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# Chisel smoke test — runs rubyn-code's Chisel layer against a committed,
+# deliberately over-engineered fixture and asserts a CONSISTENT result every
+# time. Deterministic and offline (no LLM): the debt scanner, mode resolution,
+# inspection-prompt assembly, and command registration are all pure.
+#
+#   $ bundle exec ruby skills/self_test/chisel_smoke.rb
+#
+# Prints one `CHISEL <area>: PASS/FAIL` line per area, a final `CHISEL: PASS`
+# (or `FAIL`), and exits non-zero if anything failed — so CI and the
+# /skill self-test scorecard can both consume it.
+
+require_relative '../../lib/rubyn_code'
+
+C = RubynCode::Chisel
+FIXTURE_DIR = File.expand_path('fixtures', __dir__)
+
+# The exact, repeatable output the scanner must produce for the fixture. If you
+# edit skills/self_test/fixtures/chisel_sample.rb, update this table to match.
+EXPECTED_DEBT = [
+  { file: 'chisel_sample.rb', line: 18, note: 'collapse this factory into a single build method' },
+  { file: 'chisel_sample.rb', line: 39, note: 'replace this class with Array#sum at the single call site' },
+  { file: 'chisel_sample.rb', line: 52, note: 'inline DEFAULTS[:retries] since there is only one reader' }
+].freeze
+
+results = {}
+
+# 1. Debt scanner — the consistent-result core. Scan only the fixture dir so
+#    the outcome never depends on the rest of the tree.
+scanned = RubynCode::Chisel::Debt.scan(FIXTURE_DIR)
+actual = scanned.map { |i| { file: i.file, line: i.line, note: i.note } }
+results['debt'] = (actual == EXPECTED_DEBT)
+warn("  debt mismatch — expected #{EXPECTED_DEBT.inspect}, got #{actual.inspect}") unless results['debt']
+
+# 2. Engine — off injects nothing; lite/full/ultra layer the right addenda and
+#    ALWAYS keep the safety floor; a garbage mode never crashes or leaks through.
+#    Driven via RUBYN_CHISEL_MODE so it ignores this machine's chisel_mode config.
+ENV['RUBYN_CHISEL_MODE'] = 'off'
+off_ok = !C.enabled? && C.mode == 'off' && C.prompt_section.empty?
+
+ENV['RUBYN_CHISEL_MODE'] = 'lite'
+lite = C.prompt_section
+lite_ok = C.enabled? && lite.include?(C::LADDER) && lite.include?(C::SAFETY_FLOOR) && !lite.include?(C::FULL_ADDENDUM)
+
+ENV['RUBYN_CHISEL_MODE'] = 'full'
+full = C.prompt_section
+full_ok = full.include?(C::FULL_ADDENDUM) && full.include?(C::SAFETY_FLOOR) && !full.include?(C::ULTRA_ADDENDUM)
+
+ENV['RUBYN_CHISEL_MODE'] = 'ultra'
+ultra = C.prompt_section
+ultra_ok = ultra.include?(C::ULTRA_ADDENDUM) && ultra.include?(C::SAFETY_FLOOR)
+
+ENV['RUBYN_CHISEL_MODE'] = 'definitely-not-a-mode'
+typo_ok = C::MODES.include?(C.mode) && C.mode != 'definitely-not-a-mode'
+ENV.delete('RUBYN_CHISEL_MODE')
+results['engine'] = off_ok && lite_ok && full_ok && ultra_ok && typo_ok
+
+# 3. Inspection — both scopes assemble a String carrying the ladder + safety
+#    floor and naming the fixture; an unknown scope raises instead of emitting junk.
+insp = RubynCode::Chisel::Inspection
+diff_p = insp.prompt(scope: :diff, target: 'main')
+repo_p = insp.prompt(scope: :repo, target: FIXTURE_DIR)
+raised = begin
+  insp.prompt(scope: :bogus)
+  false
+rescue ArgumentError
+  true
+end
+results['inspection'] = diff_p.is_a?(String) && diff_p.include?(C::LADDER) &&
+                        diff_p.include?(C::SAFETY_FLOOR) &&
+                        repo_p.include?(C::LADDER) && repo_p.include?(FIXTURE_DIR) && raised
+
+# 4. Command registry — all five Chisel commands register and resolve by name.
+reg = RubynCode::CLI::Commands::Registry.new
+[RubynCode::CLI::Commands::Chisel, RubynCode::CLI::Commands::ChiselReview,
+ RubynCode::CLI::Commands::ChiselAudit, RubynCode::CLI::Commands::ChiselDebt,
+ RubynCode::CLI::Commands::ChiselGain].each { |cmd| reg.register(cmd) }
+results['commands'] = %w[/chisel /chisel-review /chisel-audit /chisel-debt /chisel-gain].all? { |n| reg.known?(n) }
+
+results.each { |area, ok| puts "CHISEL #{area}: #{ok ? 'PASS' : 'FAIL'}" }
+all_ok = results.values.all?
+puts(all_ok ? 'CHISEL: PASS' : 'CHISEL: FAIL')
+exit(all_ok ? 0 : 1)

data/skills/self_test/fixtures/chisel_sample.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# Chisel self-test fixture — a DELIBERATELY over-engineered Ruby file.
+#
+# rubyn-code points Chisel at this file to get consistent, repeatable results:
+#   - `Chisel::Debt.scan` on this directory must harvest EXACTLY the three
+#     own-line `chisel:` markers below — and none of the decoys at the bottom.
+#   - `/chisel-review` and `/chisel-audit` have real over-engineering to flag.
+#
+# Do NOT "clean this up" — the smells and the markers are the point. The smoke
+# test that asserts on this file lives in skills/self_test/chisel_smoke.rb and
+# spec/rubyn_code/chisel/self_test_fixture_spec.rb. If you change a marker, the
+# line/note it sits on, or add/remove one, update those two in lock-step.
+module ChiselFixture
+  # An abstract factory with exactly one product shape — classic premature
+  # abstraction. A plain method (or just calling the class) would do.
+  class GreeterFactory
+    # chisel: collapse this factory into a single build method
+    def self.create(kind)
+      case kind
+      when :formal then FormalGreeter.new
+      when :casual then CasualGreeter.new
+      end
+    end
+  end
+
+  class FormalGreeter
+    def greet(name) = "Good day, #{name}."
+  end
+
+  class CasualGreeter
+    def greet(name) = "hey #{name}"
+  end
+
+  # A stateful wrapper that adds nothing over Array#sum.
+  class Accumulator
+    def initialize = (@total = 0)
+
+    # chisel: replace this class with Array#sum at the single call site
+    def add(amount)
+      @total += amount
+      self
+    end
+
+    def total = @total
+  end
+
+  # Single-reader config indirection.
+  DEFAULTS = { retries: 3 }.freeze
+
+  def self.retries
+    # chisel: inline DEFAULTS[:retries] since there is only one reader
+    DEFAULTS.fetch(:retries)
+  end
+
+  # --- decoys: these MUST NOT be harvested as debt markers ---
+
+  def self.decoy
+    # The next line has "chisel:" inside a string AND as a trailing comment;
+    # neither is an own-line marker, so the scanner must ignore both.
+    label = 'see # chisel: this is data, not a marker' # chisel: trailing, ignored
+    label
+  end
+end