@zalom/plastic 1.0.0-alpha.2 → 1.0.0-alpha.21

package/scripts/migrate-to-global

@@ -17,7 +17,7 @@ GLOBAL_ROOT="$HOME/.plastic"
 LOCAL_PLASTIC="$PROJECT_PATH/.plastic"
 
 if [ ! -d "$GLOBAL_ROOT" ]; then
-  echo "Error: Global Plastic not installed. Run /plastic:install first." >&2
+  echo "Error: Global Plastic not installed. Run /plastic-install first." >&2
   exit 1
 fi
 

package/scripts/select-update-target

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+# plastic-script-version: 1.0.0
+# Channel-aware update target selector.
+#
+# Usage: npm view @zalom/plastic dist-tags --json | select-update-target <current-version>
+#
+# Prints the best update target to stdout, or nothing if already up to date.
+#
+# Rule: target = the highest version, among the dist-tags reachable from the
+# installed channel, that is strictly greater than the installed version (semver).
+#   alpha installed  -> reachable: alpha, beta, latest
+#   beta installed   -> reachable: beta, latest   (never downgrade to alpha)
+#   stable installed -> reachable: latest         (stable only)
+# A prerelease (1.1.0-alpha.1) is LOWER than its release (1.1.0); the `latest`
+# placeholder (0.0.1) is naturally excluded as lower than any 1.0.0-alpha.N.
+
+require "json"
+
+# Parse "MAJOR.MINOR.PATCH[-prerelease]" into a comparable structure.
+# Returns nil for anything that isn't a clean semver string.
+def parse(version)
+  m = /\A(\d+)\.(\d+)\.(\d+)(?:-(.+))?\z/.match(version.to_s.strip)
+  return nil unless m
+  { maj: m[1].to_i, min: m[2].to_i, pat: m[3].to_i,
+    pre: m[4] ? m[4].split(".") : nil }
+end
+
+# Semver precedence (§11). Returns -1, 0, or 1.
+def compare(a, b)
+  %i[maj min pat].each do |k|
+    return a[k] <=> b[k] unless a[k] == b[k]
+  end
+  # A version with no prerelease is greater than one with a prerelease.
+  return 0 if a[:pre].nil? && b[:pre].nil?
+  return 1 if a[:pre].nil?
+  return -1 if b[:pre].nil?
+  [a[:pre].length, b[:pre].length].max.times do |i|
+    x = a[:pre][i]
+    y = b[:pre][i]
+    return -1 if x.nil?
+    return 1 if y.nil?
+    xn = x.match?(/\A\d+\z/)
+    yn = y.match?(/\A\d+\z/)
+    if xn && yn
+      return x.to_i <=> y.to_i unless x.to_i == y.to_i
+    elsif xn
+      return -1 # numeric identifiers rank lower than alphanumeric
+    elsif yn
+      return 1
+    elsif x != y
+      return x <=> y
+    end
+  end
+  0
+end
+
+def channel(version)
+  return "alpha" if version.include?("-alpha")
+  return "beta" if version.include?("-beta")
+  "stable"
+end
+
+REACH = {
+  "alpha"  => %w[alpha beta latest],
+  "beta"   => %w[beta latest],
+  "stable" => %w[latest],
+}.freeze
+
+current = ARGV[0]
+cur = parse(current)
+exit 0 unless cur
+
+begin
+  tags = JSON.parse($stdin.read)
+rescue JSON::ParserError, StandardError
+  exit 0
+end
+exit 0 unless tags.is_a?(Hash)
+
+best = nil
+best_parsed = nil
+REACH[channel(current)].each do |tag|
+  raw = tags[tag]
+  next unless raw
+  parsed = parse(raw)
+  next unless parsed
+  if compare(parsed, cur) > 0 && (best_parsed.nil? || compare(parsed, best_parsed) > 0)
+    best = raw
+    best_parsed = parsed
+  end
+end
+
+print best if best

package/scripts/uninstall.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Plastic — `uninstall` verb. Runs via `npx @zalom/plastic uninstall` (bin/plastic.js) or directly.
+# Usage: ruby scripts/uninstall.rb [--claude|--codex|--hermes|--all] [--help]
+#
+# Manifest-driven removal of installed files + legacy-plugin migration. Leaves ~/.plastic/
+# (intent store, config, and the versions.json ledger) in place — the ledger is permanent.
+
+require_relative "lib/installer_core"
+
+class Uninstall < InstallerCore
+  def cli(argv = ARGV)
+    if argv.include?("--help") || argv.include?("-h")
+      show_help
+      return 0
+    end
+
+    selected = agent_keys_from(argv)
+    selected = ["claude"] if selected.empty?
+
+    puts "\n\u{1f9e0} Plastic v#{version} — uninstall\n\n"
+    handle_uninstall(selected)
+    0
+  end
+
+  private
+
+  def show_help
+    puts <<~HELP
+
+      plastic uninstall — remove Plastic from an agent
+
+      Usage:
+        npx @zalom/plastic uninstall [options]
+
+      Agent options:
+        --claude      Uninstall from Claude Code (default)
+        --codex       Uninstall from Codex CLI
+        --hermes      Uninstall from Hermes
+        --all         Uninstall from all supported agents
+
+      Other options:
+        -h, --help    Show this help
+
+      Leaves your intent store, config, and version ledger (~/.plastic/) in place.
+
+    HELP
+  end
+end
+
+exit(Uninstall.new(package_root: ENV["PLASTIC_PACKAGE_ROOT"] || File.expand_path("..", __dir__)).cli(ARGV)) if $PROGRAM_NAME == __FILE__

package/scripts/update.rb

@@ -0,0 +1,142 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Plastic — `update` verb. Runs via `npx @zalom/plastic update` (bin/plastic.js) or directly.
+# Usage: ruby scripts/update.rb [--beta|--latest|--alpha] [--claude|--codex|--hermes|--all] [--help]
+#
+# Forward-only version transitions, sourced from npm dist-tags:
+#   - no flag                = next version on the CURRENT channel (derived from VERSION)
+#   - --beta/--latest/--alpha = switch channel. Toward stability (alpha->beta->latest) is
+#                               frictionless; toward bleeding edge requires confirmation.
+# "Already up to date" is a clean no-op. Performs the switch by delegating the file-sync to
+# `install --reinstall --ledger-action update` for the chosen version via npx.
+
+require_relative "lib/installer_core"
+
+class Update < InstallerCore
+  PKG = "@zalom/plastic"
+
+  def cli(argv = ARGV)
+    if argv.include?("--help") || argv.include?("-h")
+      show_help
+      return 0
+    end
+
+    iv = installed_version
+    unless iv
+      warn "Plastic is not installed. Run: npx #{PKG} install --claude"
+      return 1
+    end
+
+    requested = requested_channel(argv)
+    tags = fetch_dist_tags
+    unless tags
+      warn "Could not query npm dist-tags. Are you online?"
+      return 1
+    end
+
+    res = compute_target(installed_version: iv, dist_tags: tags, requested_channel: requested)
+
+    case res[:status]
+    when :up_to_date
+      puts "\u{2705} Plastic v#{iv} is already up to date on the #{channel_for(iv)} channel."
+      return 0
+    when :unknown_channel
+      warn "No published version on the #{requested} channel."
+      return 1
+    when :ok
+      if res[:kind] == :cross_bleeding && !confirm_bleeding(iv, res[:target])
+        puts "Aborted."
+        return 1
+      end
+      puts "\u{2b06}\u{fe0f}  Updating Plastic #{iv} \u{2192} #{res[:target]}"
+      perform_switch(res[:target], agent_args(argv))
+    end
+  end
+
+  # Pure decision logic (hermetically testable). Returns a status hash.
+  def compute_target(installed_version:, dist_tags:, requested_channel: nil)
+    installed_ch = channel_for(installed_version)
+    target_ch = requested_channel || installed_ch
+    cand = dist_tags[target_ch]
+    return { status: :unknown_channel } unless cand
+
+    if target_ch == installed_ch
+      return { status: :up_to_date } unless semver_gt?(cand, installed_version)
+      { status: :ok, target: cand, kind: :in_channel }
+    else
+      bleeding = stability_rank(target_ch) < stability_rank(installed_ch)
+      { status: :ok, target: cand, kind: bleeding ? :cross_bleeding : :cross_stable }
+    end
+  end
+
+  def installed_version
+    path = File.join(plastic_home, "VERSION")
+    File.exist?(path) ? File.read(path).strip : nil
+  end
+
+  private
+
+  def requested_channel(argv)
+    return "alpha" if argv.include?("--alpha")
+    return "beta" if argv.include?("--beta")
+    return "latest" if argv.include?("--latest")
+    nil
+  end
+
+  # Agent flags to pass through to the delegated install (default --claude).
+  def agent_args(argv)
+    flags = agents.map { |a| a[:flag] }.select { |f| argv.include?(f) }
+    flags << "--all" if argv.include?("--all")
+    flags.empty? ? ["--claude"] : flags
+  end
+
+  def fetch_dist_tags
+    raw = `npm view #{PKG} dist-tags --json 2>/dev/null`
+    return nil if raw.nil? || raw.strip.empty?
+    JSON.parse(raw)
+  rescue JSON::ParserError, StandardError
+    nil
+  end
+
+  def confirm_bleeding(current, target)
+    return false unless $stdin.tty?
+    print "Switch from #{current} to the less-stable #{target}? [y/N]: "
+    ($stdin.gets&.strip || "").downcase.start_with?("y")
+  end
+
+  # Thin npx-exec glue (not unit-tested; the decision above is). Delegates the file-sync to
+  # the target version's install verb, recording the ledger action as `update`.
+  def perform_switch(target, agent_flags)
+    cmd = ["npx", "#{PKG}@#{target}", "install", "--reinstall", "--ledger-action", "update", *agent_flags]
+    puts "  $ #{cmd.join(" ")}"
+    system(*cmd) ? 0 : 1
+  end
+
+  def show_help
+    puts <<~HELP
+
+      plastic update — upgrade Plastic to a newer version
+
+      Usage:
+        npx @zalom/plastic update [options]
+
+      Channel options (default: stay on the current channel):
+        --latest      Switch to / advance the stable channel
+        --beta        Switch to / advance the beta channel
+        --alpha       Switch to / advance the alpha channel (bleeding edge — confirmed)
+
+      Agent options (default: --claude):
+        --claude --codex --hermes --all
+
+      Behaviour:
+        No flag advances to the next version on your current channel. Switching toward a
+        more stable channel is frictionless; switching toward bleeding edge is confirmed.
+        Use `versions` to roll back to a previously-installed version.
+
+    HELP
+  end
+end
+
+exit(Update.new(package_root: ENV["PLASTIC_PACKAGE_ROOT"] || File.expand_path("..", __dir__)).cli(ARGV)) if $PROGRAM_NAME == __FILE__

package/scripts/versions.rb

@@ -0,0 +1,141 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Plastic — `versions` verb. Runs via `npx @zalom/plastic versions` (bin/plastic.js) or directly.
+# Usage: ruby scripts/versions.rb [--downgrade [--version <v>] | --upgrade] [--help]
+#
+# Local time-machine over the append-only versions.json ledger. Navigates ONLY versions you
+# have actually run (the ledger), never npm's full list — fetching brand-new versions is
+# `update`'s job. Lets you roll back to a known-good build after a bad release.
+#   - no flag                  print the ledger table (and offer to continue a rollback)
+#   - --downgrade              step back one version in your history
+#   - --downgrade --version V  jump to a specific previously-run version
+#   - --upgrade                step forward one version (after a rollback)
+
+require_relative "lib/installer_core"
+
+class Versions < InstallerCore
+  PKG = "@zalom/plastic"
+
+  def cli(argv = ARGV)
+    if argv.include?("--help") || argv.include?("-h")
+      show_help
+      return 0
+    end
+
+    ledger = ledger_read
+    if ledger.empty?
+      puts "No version history yet (versions.json is empty). Install or update first."
+      return 0
+    end
+
+    timeline = version_timeline(ledger)
+    current = installed_version || timeline.last
+
+    if argv.include?("--downgrade")
+      explicit = flag_value(argv, "--version")
+      target = explicit || step_target(timeline, current, :back)
+      return no_target("No earlier version in your history.") unless target
+      unless timeline.include?(target)
+        warn "#{target} is not in your version history. Choose one of: #{timeline.join(", ")}"
+        return 1
+      end
+      return switch_to(target, current)
+    elsif argv.include?("--upgrade")
+      target = step_target(timeline, current, :forward)
+      return no_target("No later version in your history. Use `update` for new releases.") unless target
+      return switch_to(target, current)
+    end
+
+    # No flag: show the table, and detect an in-progress rollback.
+    print_table(ledger, current)
+    if ledger.last && ledger.last["action"] == "downgrade"
+      prev = step_target(timeline, current, :back)
+      if prev && $stdin.tty?
+        print "\nYou recently rolled back. Go back further to #{prev}? [y/N]: "
+        return switch_to(prev, current) if ($stdin.gets&.strip || "").downcase.start_with?("y")
+      end
+    end
+    0
+  end
+
+  # Unique versions in first-seen (chronological) order — the user's personal timeline.
+  def version_timeline(ledger)
+    ledger.map { |e| e["version"] }.compact.uniq
+  end
+
+  # Neighbour of `current` in the timeline. direction :back (older) or :forward (newer).
+  def step_target(timeline, current, direction)
+    i = timeline.index(current)
+    return nil if i.nil?
+    j = direction == :back ? i - 1 : i + 1
+    return nil if j < 0 || j >= timeline.length
+    timeline[j]
+  end
+
+  # Direction-derived ledger action for moving current -> target.
+  def action_for(target, current)
+    cmp = semver_compare(target, current)
+    cmp == -1 ? "downgrade" : "update"
+  end
+
+  def installed_version
+    path = File.join(plastic_home, "VERSION")
+    File.exist?(path) ? File.read(path).strip : nil
+  end
+
+  private
+
+  def flag_value(argv, name)
+    i = argv.index(name)
+    return nil unless i && argv[i + 1]
+    argv[i + 1]
+  end
+
+  def no_target(msg)
+    puts msg
+    0
+  end
+
+  def switch_to(target, current)
+    action = action_for(target, current)
+    puts "#{action == "downgrade" ? "\u{23ea}" : "\u{23e9}"}  #{current} \u{2192} #{target} (#{action})"
+    cmd = ["npx", "#{PKG}@#{target}", "install", "--reinstall", "--ledger-action", action, "--claude"]
+    puts "  $ #{cmd.join(" ")}"
+    system(*cmd) ? 0 : 1
+  end
+
+  def print_table(ledger, current)
+    puts "\nPlastic version history (versions.json — append-only):\n\n"
+    puts "    %-22s %-10s %s" % ["version", "action", "at"]
+    ledger.each do |e|
+      marker = e["version"] == current ? "\u{2192} " : "  "
+      puts "  #{marker}%-22s %-10s %s" % [e["version"], e["action"], e["at"]]
+    end
+    puts "\n  \u{2192} = currently installed (v#{current})\n\n"
+  end
+
+  def show_help
+    puts <<~HELP
+
+      plastic versions — manage and roll back your local Plastic versions
+
+      Usage:
+        npx @zalom/plastic versions [options]
+
+      Options:
+        (none)                  Show the version-history table
+        --downgrade             Roll back one version in your history
+        --downgrade --version V Roll back to a specific previously-run version
+        --upgrade               Step forward one version in your history
+        -h, --help              Show this help
+
+      Navigates only versions you have already run (the append-only ledger). To move to a
+      brand-new release, use `update`.
+
+    HELP
+  end
+end
+
+exit(Versions.new(package_root: ENV["PLASTIC_PACKAGE_ROOT"] || File.expand_path("..", __dir__)).cli(ARGV)) if $PROGRAM_NAME == __FILE__

package/skills/_active-intent-gate.md

@@ -0,0 +1,26 @@
+## Active Intent Gate
+
+Before proceeding, resolve the active intent:
+
+1. **Detect store:**
+   - Read `~/.plastic/projects.yml`
+   - Match CWD against registered project paths
+   - If match → project store at `~/.plastic/projects/{slug}/store/`
+   - If no match → global store at `~/.plastic/store/`
+
+2. **Find active intent:**
+   - Read `INDEX.md` from the detected store
+   - Look under `## Active` for intent entries
+   - If exactly one active intent → use it
+   - If multiple active intents → ask user which one
+   - If no active intent → refuse: "No active intent. Create one first with /plastic-creating-intent"
+
+3. **Resolve paths:**
+   - Intent directory: `{store}/store/{id}--{slug}/`
+   - Spec: `{intent_dir}/spec.md`
+   - Plan: `{intent_dir}/plan.md`
+   - Checklist: `{intent_dir}/checklist.md`
+   - Resources: `{intent_dir}/resources/`
+   - Outcome: `{intent_dir}/outcome.md`
+
+All lifecycle artifacts MUST be written to the intent directory. Never write to `docs/superpowers/specs/`, `docs/superpowers/plans/`, or any other external path.

package/skills/auto/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: plastic:auto
+name: plastic-auto
 description: >-
   Autonomous intent delivery — agent takes over How and Exec. Use when user says
   "auto", "take it from here", "deliver this", or when brainstorming-grill-me concludes
@@ -12,10 +12,41 @@ Announce: "Taking over intent [ID] — [name] for autonomous delivery."
 
 ## Precondition
 
-An active intent MUST exist in INDEX.md. If none exists, refuse: "No active intent found. Create one first with /plastic:creating-intent."
+An active intent MUST exist in INDEX.md. If none exists, refuse: "No active intent found. Create one first with /plastic-creating-intent."
 
 If multiple active intents exist, ask the user which one to deliver (this is the only question auto asks).
 
+**Picking work when no intent is specified.** If the user says "auto" without naming an
+intent and none is active, consult the dashboard's machine-readable queue to choose the
+next dispatchable intent:
+
+```bash
+ruby ~/.plastic/scripts/dashboard.rb all --json
+```
+
+Work `dispatchable_queue` in `rank` order (these are `defer`/`research` dispositions —
+safe to deliver autonomously). Leave `human_only` and `next_big_thing` for the user — those
+are `drive`/`triage` items the human should lead. See the `plastic-dashboard` skill.
+
+## Arm the Lifecycle Gate (do this FIRST)
+
+Immediately after selecting the intent — before any other work — arm auto mode. This
+writes the session bridge that makes the code-edit gate live, so project code cannot be
+edited before the plan exists (the gate applies to YOU, the orchestrator):
+
+```bash
+ruby -r ~/.plastic/scripts/lib/bridge -e \
+  'Bridge.arm_auto(ENV["CLAUDE_SESSION_ID"], intent_id: "<ID>", intent_dir: "<STORE>/<dir>", store: "<STORE>", name: "<name>")'
+```
+
+Replace `<ID>`, `<STORE>` (e.g. `~/.plastic/projects/<slug>/store` or `~/.plastic/store`),
+`<dir>` (the `ID--slug` directory), and `<name>`. If `CLAUDE_SESSION_ID` is unset, arming
+is best-effort — proceed regardless; the gate simply won't engage.
+
+**Hard rule for the rest of this run:** do NOT edit project code (anything outside the
+intent directory / `~/.plastic/`) until `plan.md` AND `checklist.md` exist for the intent.
+Honor the cycle: What → Why (spec.md) → How (plan.md + actions/ + checklist.md) → Exec.
+
 ## Flags
 
 - `--skip-permissions` — bypass hard stops on destructive actions on existing projects. Full trust mode. Default: off.
@@ -67,7 +98,7 @@ If the plan calls for creating a new project (the intent is an implementation in
 1. Determine project path from `~/.plastic/config.yml` `project_roots` or from intent context
 2. **Confirm path with user** — this is the ONE human interaction during auto delivery:
    > "Creating project `<slug>` at `<path>`. Confirm path, or provide alternative."
-3. Invoke `plastic:creating-project` skill
+3. Invoke `plastic-creating-project` skill
 4. The global intent is now Completed (creating-project handles this)
 5. The tactical mirror in the project store becomes the active intent
 6. Continue execution from the project directory using the tactical intent
@@ -75,7 +106,7 @@ If the plan calls for creating a new project (the intent is an implementation in
 ## Exec Phase
 
 1. If `superpowers:subagent-driven-development` or `superpowers:executing-plans` is available, delegate execution to it
-2. Otherwise invoke `plastic:executing-plan`
+2. Otherwise invoke `plastic-executing-plan`
 3. Execute actions from checklist sequentially
 4. Check off items in `checklist.md` as completed
 5. Append observations to `## Insights` with `(autonomous)` marker
@@ -111,12 +142,30 @@ During initial project creation, all decisions are non-destructive by definition
 1. Verify all checklist items are checked
 2. Write `outcome.md` with detailed results
 3. Write `## Outcome` summary in the intent file (1-2 sentences)
-4. Review `## Insights` for observations that should spawn future intents. If any:
-   - Create them (using `plastic:creating-intent` conventions)
+4. **Release (if configured)**
+   1. Detect project — match CWD against paths in `~/.plastic/projects.yml` to find the project slug. If no match, skip to step 5 (default commit-only behavior).
+   2. Read `~/.plastic/projects/{slug}/project.yml`. If the file doesn't exist or has no `release` key, skip to step 5.
+   3. Based on `release.on_complete`:
+      - `commit` — git add + commit (same as default, proceed to step 5)
+      - `commit_and_push` — git add + commit + push
+      - `manual` — skip auto-commit, notify user: "Release configured as manual — commit when ready."
+   4. If `release.verify` is set, run the verify command (e.g. `bundle exec rake test`):
+      - **Exit 0 (green):** proceed to sub-step 5
+      - **Non-zero (red):** check `release.on_red`:
+        - `fix_and_retry` — attempt to fix the failure, re-run verify (max 2 retries)
+        - `stop` — write `savepoint.md` with current state, notify user: "Verify failed — savepoint written.", **STOP**
+        - `manual` — notify user: "Verify failed: [summary]. Resolve manually."
+   5. If `release.on_green` has items, invoke `plastic-releasing` to handle them (tag, changelog, publish, etc.). Do NOT duplicate release logic — delegate entirely.
+5. Review `## Insights` for observations that should spawn future intents. If any:
+   - Create them (using `plastic-creating-intent` conventions)
    - Update `chain` in the current intent's frontmatter
-5. Move intent from `## Active` to `## Completed` in INDEX.md (with today's date)
-6. Auto-commit: `cd <store-root> && git add . && git commit -m "feat: deliver intent <ID> — <name>"`
-7. Notify user: "Intent [ID] — [name] delivered. [1-2 sentence summary]. See outcome.md for details."
+6. Move intent from `## Active` to `## Completed` in INDEX.md (with today's date)
+7. Auto-commit: `cd <store-root> && git add . && git commit -m "feat: deliver intent <ID> — <name>"`
+8. Disarm the lifecycle gate (auto delivery is finished):
+   ```bash
+   ruby -r ~/.plastic/scripts/lib/bridge -e 'Bridge.disarm_auto(ENV["CLAUDE_SESSION_ID"])'
+   ```
+9. Notify user: "Intent [ID] — [name] delivered. [1-2 sentence summary]. See outcome.md for details."
 
 ## Error Handling
 
@@ -125,3 +174,7 @@ If the agent gets stuck (can't resolve a gap, dependency is missing, tests fail
 2. Write `savepoint.md` with current state
 3. Notify user: "Blocked on intent [ID] — [name]: [description]. Savepoint written."
 4. **STOP.** Do not attempt workarounds that could leave the project in a broken state.
+
+## References
+
+- Read `references/agent-architecture.md` for the full agent hierarchy (Main Orchestrator, Project Orchestrators, coordination loop) when dispatching agents or understanding autonomous delivery scope

package/skills/auto/evals/evals.json

@@ -0,0 +1,92 @@
+{
+  "skill_name": "plastic-auto",
+  "notes": "Intent 27. Scopes: description triggering (1-8) and behavior/output quality (9). Assertions written after observing Step-3 runs (one clean subagent router per case).",
+  "results": {
+    "triggering": { "cases": 8, "passed": 8, "pass_at_1": 1.0, "run": "2026-06-10, one subagent per case" },
+    "behavior": { "cases": 1, "passed": 1, "evidence": "dogfood: intent 27 itself delivered via auto produced spec->plan->checklist before any code edit; code-gate unit test proves pre-How project-code edits are blocked" }
+  },
+  "evals": [
+    {
+      "id": 1, "scope": "triggering", "set": "train",
+      "prompt": "auto",
+      "expected_output": "Activates plastic-auto (the bare 'auto' keyword is the documented trigger).",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-auto", "observed": "plastic-auto", "result": "pass" }
+      ]
+    },
+    {
+      "id": 2, "scope": "triggering", "set": "train",
+      "prompt": "take it from here and deliver intent 27 end to end",
+      "expected_output": "Activates plastic-auto (autonomous delivery of an active intent).",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-auto", "observed": "plastic-auto", "result": "pass" }
+      ]
+    },
+    {
+      "id": 3, "scope": "triggering", "set": "validation",
+      "prompt": "go fully autonomous on the active intent, don't ask me questions",
+      "expected_output": "Activates plastic-auto.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-auto", "observed": "plastic-auto", "result": "pass" }
+      ]
+    },
+    {
+      "id": 4, "scope": "triggering", "set": "train",
+      "prompt": "deliver this intent for me",
+      "expected_output": "Activates plastic-auto.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-auto", "observed": "plastic-auto", "result": "pass" }
+      ]
+    },
+    {
+      "id": 5, "scope": "triggering", "set": "train",
+      "prompt": "set up a hook to automatically format the file on every save",
+      "expected_output": "Does NOT activate plastic-auto. Near-miss: shares 'auto*' but is a settings/hooks task (update-config).",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE != plastic-auto", "observed": "update-config", "result": "pass" }
+      ]
+    },
+    {
+      "id": 6, "scope": "triggering", "set": "validation",
+      "prompt": "deliver the built package to the dist directory",
+      "expected_output": "Does NOT activate plastic-auto. Near-miss: shares 'deliver' but is a build/file task.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE != plastic-auto", "observed": "none", "result": "pass" }
+      ]
+    },
+    {
+      "id": 7, "scope": "triggering", "set": "train",
+      "prompt": "create a new intent for the dashboard idea",
+      "expected_output": "Does NOT activate plastic-auto; activates plastic-creating-intent.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE != plastic-auto", "observed": "plastic-creating-intent", "result": "pass" }
+      ]
+    },
+    {
+      "id": 8, "scope": "triggering", "set": "validation",
+      "prompt": "what's the status of my active intents?",
+      "expected_output": "Does NOT activate plastic-auto; this is a read/continuing/managing-index query.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE != plastic-auto", "observed": "plastic-managing-index", "result": "pass" }
+      ]
+    },
+    {
+      "id": 9, "scope": "behavior", "set": "train",
+      "prompt": "Active intent X exists with only a '## Intent' section. Deliver it in auto mode.",
+      "expected_output": "Arms the lifecycle gate first, then produces spec.md (Why), then plan.md + actions/ + checklist.md (How), and edits NO project code before plan.md + checklist.md exist. Disarms on completion.",
+      "files": [],
+      "assertions": [
+        { "type": "human", "check": "spec.md written before plan.md before any project-code edit", "observed": "dogfood run of intent 27 followed this order", "result": "pass" },
+        { "type": "code", "check": "code-gate blocks project-code Edit/Write while pre-How (test/code_gate_test.rb)", "observed": "test green", "result": "pass" }
+      ]
+    }
+  ]
+}