@zalom/plastic 1.14.0 → 2.0.0-alpha.1

package/skills/skill-creating/references/scripts.md

@@ -1,166 +0,0 @@
-# Scripts: when deterministic code beats prose
-
-Decide whether a skill ships a script, and write scripts that hold their determinism.
-Read this when choosing script versus prose, or when writing a script that ships with a
-skill.
-
-For which bucket holds a given piece of content (scripts versus references versus
-assets), read `references/progressive-disclosure.md`. This file covers only the
-script-or-prose decision and script discipline.
-
-## Contents
-
-- [Ship a script or write prose](#ship-a-script-or-write-prose)
-- [The three-way test](#the-three-way-test)
-- [Make scripts solve, not punt](#make-scripts-solve-not-punt)
-- [Test by running](#test-by-running)
-- [Match freedom to fragility](#match-freedom-to-fragility)
-- [Wire validators into hooks](#wire-validators-into-hooks)
-- [Script hard requirements](#script-hard-requirements)
-- [Plastic conventions](#plastic-conventions)
-- [Worked example](#worked-example)
-- [Self-check](#self-check)
-
-## Ship a script or write prose
-
-Ship a script when either condition holds:
-
-1. The same code gets rewritten on every run.
-2. Deterministic reliability matters (one wrong character breaks the result).
-
-Otherwise write prose. A script is executed, not loaded, so its body stays out of
-context and costs no tokens at trigger time. The price is an indirection: the agent must
-find the script, learn its interface, and run it. Pay that price only when repetition or
-determinism earns it. [G1]
-
-## The three-way test
-
-When something repeats, route it by what repeats, not by gut feel. [G2]
-
-| What repeats | Bucket | Why |
-| --- | --- | --- |
-| Identical code | `scripts/` | Run it; do not regenerate it each time. |
-| Identical boilerplate output | `assets/` (template) | Copy the template into output; never read it into context. |
-| Re-discovered facts | `references/` | Read it once, on the trigger that needs it. |
-
-A symptom of the wrong choice: an agent pasting the same 30 lines of Ruby across three
-runs belongs in `scripts/`, not in prose; a fixed file header the agent retypes belongs
-in `assets/`; a constant the agent keeps looking up belongs in `references/`.
-
-## Make scripts solve, not punt
-
-A script that hands its failure back to the agent loses the determinism that justified
-shipping it. [G3]
-
-- Handle errors inside the script. Catch the failure, print a clear diagnostic to stderr,
-  and exit non-zero. Do not raise a raw stack trace and leave the agent to interpret it.
-- No voodoo constants. Every magic number, path, or threshold gets a name and a comment
-  stating where it came from. An unexplained `0.87` is a future break.
-- State the mode. Say explicitly whether the agent executes the script or reads it. A
-  validator is executed; a snippet meant to be copied is read. Ambiguity makes the agent
-  guess.
-
-## Test by running
-
-An untested script is a latent break. Run it against real input before shipping. [G4]
-
-- Exercise the success path and at least one failure path; confirm the exit code and the
-  stderr message.
-- Delete any example or scratch files the run generated that the skill does not ship.
-  Stray files are clutter and may load by accident.
-
-## Match freedom to fragility
-
-Match degrees of freedom to fragility. Put guardrails on the narrow bridge, not the open
-field. [G6]
-
-| Task shape | Form | Reason |
-| --- | --- | --- |
-| Open, judgment-heavy | Prose | The agent needs room to adapt; code would over-constrain. |
-| A preferred, repeatable pattern | Parameterized script (flags/env) | One correct shape, with controlled variation. |
-| Fragile or destructive sequence | Fixed "do not modify" script | One exact path; any edit risks data loss. |
-
-Mark a fragile script as "do not modify" in its `--help` and in the pointer that sends the
-agent to it. For side-effecting workflows, gate execution behind a validator (see below)
-rather than trusting the agent to check preconditions by hand.
-
-## Wire validators into hooks
-
-When a rule must hold every time, wire a deterministic validator into a hook rather than
-restating the rule in prose. [G5]
-
-- A `PreToolUse` validator can refuse an action before it runs; a packaging step can
-  refuse to ship a skill that fails validation.
-- Gate destructive steps behind validate-then-act: the validator passes, then the action
-  runs. A prose reminder ("remember to check X first") is probabilistic; a hook is not.
-
-For hook event selection, exit-code semantics, and path conventions, read
-`references/hooks.md`.
-
-## Script hard requirements
-
-Every script that ships with a skill meets these, because an agent runs it unattended:
-
-1. No interactive prompts. A blocking `gets` or `read -p` hangs the agent forever. Take
-   all input up front.
-2. Input via flags, environment variables, or stdin. Never mid-run questions.
-3. `--help` is the primary documentation. Describe purpose, every flag, input, output, and
-   exit codes there, so the agent learns the interface without reading the source.
-4. Structured output. Data on stdout, diagnostics and progress on stderr, so the caller
-   can capture one without the other.
-5. Idempotent operations. Running twice produces the same end state; re-running after a
-   partial failure is safe.
-6. Meaningful, documented exit codes. 0 for success, distinct non-zero codes for distinct
-   failures, each named in `--help`.
-
-## Plastic conventions
-
-- Scripts ship in Ruby. A worked example that shows a script shows Ruby.
-- Any shell script runs under macOS `/bin/bash` 3.2. No `bash` 4.x features (no
-  associative arrays, no `mapfile`, no `${var^^}`), and no heredocs inside `$(...)`.
-
-## Worked example
-
-A skill validates that an intent slug is well formed before any directory is created. The
-check runs on every intent and must be exact, so it ships as a script, not prose. [G1][G3]
-
-`scripts/validate_slug.rb`:
-
-```ruby
-#!/usr/bin/env ruby
-# Validate an intent slug. Execute this; do not inline its logic.
-# Usage: validate_slug.rb SLUG
-# Exit: 0 valid, 1 malformed, 2 wrong argument count.
-
-# Convention source: A5 of the best-practices standard (lowercase,
-# digits, single hyphens, no leading/trailing/consecutive hyphens).
-SLUG_PATTERN = /\A[a-z0-9]+(-[a-z0-9]+)*\z/
-
-if ARGV.length != 1
-  warn "usage: validate_slug.rb SLUG"
-  exit 2
-end
-
-slug = ARGV.fetch(0)
-if SLUG_PATTERN.match?(slug)
-  puts slug            # data on stdout
-  exit 0
-else
-  warn "malformed slug: #{slug.inspect}" # diagnostic on stderr
-  exit 1
-end
-```
-
-This script earns its place: identical code on every run, one exact rule, errors handled
-inside, the named constant cites its source, data on stdout and diagnostics on stderr,
-documented exit codes, and the header states it is executed. An open task ("name this
-intent well") would stay prose; this fixed check is a script.
-
-## Self-check
-
-- Does this code repeat or demand exactness? If not, it stays prose. [G1]
-- Did the right bucket win the three-way test? [G2]
-- Are errors handled inside, constants named, and the execute-or-read mode stated? [G3]
-- Did the script run green on a success path and a failure path, with scratch files
-  removed? [G4]
-- Does fragility match form, with destructive steps gated by a validator? [G5][G6]

package/skills/skill-creating/references/skills.md

@@ -1,169 +0,0 @@
-# Authoring an Agent Skill
-
-Open this when writing or restructuring a single Agent Skill: the frontmatter, the
-description that triggers it, the body voice, and the on-disk layout. Rule ids in brackets
-(A1 through B10) point at the synthesis standard the rules come from.
-
-For the three load levels (metadata, body, resources), the thin-router pattern, and how to
-split a body into `references/`, read `progressive-disclosure.md`. This file does not repeat
-that model.
-
-## Contents
-
-- Skill file layout
-- Frontmatter fields
-- The `name` field
-- The `description` field (triggering)
-- Optional frontmatter fields
-- Body voice
-- Body content
-- Self-check
-
-## Skill file layout
-
-A skill is a directory whose name matches the `name` field. The directory holds `SKILL.md`
-plus optional buckets. Pick a bucket by how the file touches context.
-
-| Path | Loads when | Holds |
-|------|-----------|-------|
-| `SKILL.md` | The skill triggers | Frontmatter plus the body |
-| `references/` | The body points at it, on demand | Deep how-to, specs, variant material |
-| `scripts/` | Executed, never read into context | Repeated deterministic code |
-| `assets/` | Copied into output, never read | Templates, boilerplate the output needs |
-| `evals/` | Run by the eval harness | Eval cases for the skill |
-
-When picking a bucket, follow `progressive-disclosure.md` for the cross-cutting layout rules:
-references one level deep (C5), no orphan or auxiliary files in the skill (C9), and each fact
-stored once (C7).
-
-## Frontmatter fields
-
-`SKILL.md` opens with YAML frontmatter. Two fields are required.
-
-| Field | Required | Constraints |
-|-------|----------|-------------|
-| `name` | Yes | 1 to 64 chars. Lowercase alphanumeric plus hyphens. No leading, trailing, or consecutive hyphens. Matches the directory name. |
-| `description` | Yes | 1 to 1024 chars. Non-empty. States what and when. |
-
-Invent no other top-level fields. Unknown fields are ignored or rejected and add noise [A6].
-
-## The `name` field
-
-Rules [A5]:
-
-1. 64 chars or fewer.
-2. Lowercase letters, numbers, and hyphens only.
-3. No leading, trailing, or consecutive hyphens.
-4. Must match the parent directory name exactly.
-5. Must not contain `anthropic` or `claude`.
-6. Prefer the gerund form, which reads as a capability (`processing-pdfs`, `creating-skills`,
-   not `pdf-tool`).
-7. Never start with `plastic-`. That prefix is reserved for skills and hooks Plastic itself
-   ships; doctor's ownership checks (`stray_skills`) and the installer's purge both key off it,
-   so a user-authored skill carrying it reads as squatting on Plastic's own namespace.
-
-## The `description` field (triggering)
-
-The description is the only text loaded at discovery time. The body is not loaded when the
-agent decides whether to trigger, so the description alone has to win the match.
-
-Rules:
-
-1. Write the description as triggering conditions only ("Use when ..."), never as a summary of
-   the workflow [A1]. A workflow summary makes the agent act on the summary and skip the body,
-   dropping steps. Documented failure: a description that summarized "code review between
-   tasks" produced one review instead of two.
-2. Write in the third person [A2]. The description is injected into the system prompt, where
-   mixed point of view degrades discovery.
-3. State both what the skill does and when to use it, and front-load concrete trigger terms
-   [A3]. The model picks from many skills on this text and the listing is budget-truncated, so
-   terms placed late may never be read.
-4. Include at least one indirect trigger where the user does not name the domain [A4]. Real
-   prompts rarely name the skill, so a keyword-only description misses oblique requests.
-
-Shape:
-
-```yaml
-description: >
-  [One clause: what it does]. Use when [primary trigger], [secondary trigger],
-  or when [indirect trigger where the user does not name the domain].
-```
-
-For side-effecting workflows (deploy, release, destructive ops), set
-`disable-model-invocation: true` so only the user fires the skill [A7]. Auto-triggering on
-irreversible work is a known failure mode.
-
-## Optional frontmatter fields
-
-Use only the documented optionals below. Add nothing beyond them [A6].
-
-| Field | Holds |
-|-------|-------|
-| `license` | Short name or filename reference |
-| `compatibility` | Environment requirements, 1 to 500 chars, only when needed |
-| `metadata` | String-to-string map with unique keys |
-| `allowed-tools` | Space-separated tool list (experimental) |
-| `model` | Claude Code extension: pin the model for this skill |
-| `disable-model-invocation` | Claude Code extension: only the user may fire the skill |
-| `user-invocable` | Claude Code extension: set false to hide the skill from the user's / slash menu while leaving it agent-invocable; default true |
-| `context: fork` | Claude Code extension: run the body as a forked task |
-| `paths` | Claude Code extension: scope the skill to matching paths |
-
-## Body voice
-
-Rules:
-
-1. Write in imperative or infinitive voice ("Run the validator", "Extract the text"), never
-   second person ("you should", "you can") [B1]. Command voice is shorter and binds tighter;
-   hedged second-person language is a known slop pattern.
-2. Use one consistent term per concept ("extract", never also "pull", "get", "retrieve")
-   [B6]. Synonym drift makes the agent unsure whether two terms name the same operation.
-
-## Body content
-
-The body persists in context every turn the skill is active, so each line is a recurring
-cost. Spend lines only where the agent would otherwise go wrong.
-
-Rules:
-
-1. State what to do, not how or why, and cut anything the model already knows [B2]. Claude is
-   already capable; the body is for the project-specific and the non-obvious.
-2. Apply the test "would the agent get this wrong without it?" to every instruction. If no,
-   delete it [B7]. Instructions that restate default competence are pure token cost.
-3. Challenge every paragraph with "does this justify its token cost?" and prefer one excellent
-   example over many mediocre ones [B3].
-4. Lead each section with one bold maxim and close it with one concrete self-check [B4]. The
-   maxim is what survives in context; the check lets the agent apply the rule mid-task.
-5. Put gotchas as concrete corrections, placed early [B5]. A correction only helps if the
-   agent reads it before it makes the mistake. Write the specific fact, not general advice:
-
-   ```markdown
-   ## Gotchas
-   - The `users` table uses soft deletes. Queries must include `WHERE deleted_at IS NULL`.
-   - User id is `user_id` in the DB, `uid` in auth, `accountId` in billing. Same value.
-   - The `/health` endpoint returns 200 even when the DB is down. Use `/ready`.
-   ```
-
-6. Carry reference and decision material in tables and numbered lists. Use a flowchart only
-   for a genuinely non-obvious decision or an early-stop loop [B10]. Tables are denser per
-   token; flowcharts waste tokens on reference, code, or linear steps.
-7. State the tradeoff and ship an escape hatch instead of policing edge cases with long
-   rationalization tables [B8]. Add an Excuse-and-Reality table only for a discipline skill
-   where an eval has actually shown the agent rationalizing a violation.
-8. Avoid time-sensitive content. Move deprecated material into a collapsed "Old patterns"
-   section [B9]. Dated instructions rot and mislead.
-
-## Self-check
-
-Before shipping the skill, confirm each line:
-
-- [ ] `name` matches the directory, is lowercase-hyphen, and carries no `claude`/`anthropic`.
-- [ ] `description` reads as "Use when ...", third person, with front-loaded triggers and at
-      least one indirect trigger.
-- [ ] No invented frontmatter fields; optionals are drawn only from the table above.
-- [ ] Side-effecting skill sets `disable-model-invocation`.
-- [ ] Body is imperative, with one term per concept.
-- [ ] Every instruction passes "would the agent get this wrong without it?".
-- [ ] Gotchas are concrete corrections, placed early.
-- [ ] Reference and decision material is in tables or lists, not prose.
-- [ ] `references/` files are one level deep; no orphan or auxiliary files in the skill.

package/skills/skill-creating/scripts/scaffold.rb

@@ -1,313 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# scaffold.rb - born-slim starting files for a new skill, agent, or hook.
-#
-# Plastic skills, agents, and hooks start small and grow by progressive
-# disclosure. This scaffolder emits the minimum valid skeleton so the body
-# stays slim and detail moves into references/ as the work earns it.
-#
-# Usage:
-#   ruby scaffold.rb skill <name> [--out <dir>] [dest]
-#   ruby scaffold.rb agent <name> [--out <dir>] [dest]
-#   ruby scaffold.rb hook  [<Event>] <name> [--out <dir>] [dest]
-#   ruby scaffold.rb --help
-#
-# All input is positional plus flags. There are no interactive prompts, so an
-# agent never hangs waiting on input. The destination defaults to the current
-# directory; pass --out or a trailing positional to choose another directory.
-#
-# Exit codes:
-#   0  success, or --help
-#   1  usage error (unknown subcommand, missing argument)
-#   2  validation error (bad name or event)
-#   3  refused to overwrite an existing target, or a filesystem error
-#
-# This script and every file it emits contain no em-dashes; the emitted files
-# are user-facing.
-
-require "json"
-require "fileutils"
-
-EXIT_OK = 0
-EXIT_USAGE = 1
-EXIT_VALIDATION = 2
-EXIT_CONFLICT = 3
-
-NAME_PATTERN = /\A[a-z0-9]+(-[a-z0-9]+)*\z/.freeze
-EVENT_PATTERN = /\A[A-Z][A-Za-z]+\z/.freeze
-DEFAULT_EVENT = "PostToolUse"
-
-USAGE = <<~TEXT
-  scaffold.rb - born-slim starting files for a new skill, agent, or hook.
-
-  Usage:
-    ruby scaffold.rb skill <name> [--out <dir>] [dest]
-    ruby scaffold.rb agent <name> [--out <dir>] [dest]
-    ruby scaffold.rb hook  [<Event>] <name> [--out <dir>] [dest]
-    ruby scaffold.rb --help
-
-  Subcommands:
-    skill   Emit <dest>/<name>/SKILL.md, references/.gitkeep, evals/evals.json.
-    agent   Emit <dest>/<name>.md agent role file.
-    hook    Emit <dest>/<name> no-op hook handler (Ruby) wired for <Event>.
-
-  Names must be lowercase alphanumeric and hyphens, with no leading,
-  trailing, or repeated hyphens, 1 to 64 characters.
-  The hook <Event> is optional and defaults to #{DEFAULT_EVENT}.
-  The destination defaults to the current directory.
-
-  Exit codes:
-    0  success, or --help
-    1  usage error (unknown subcommand, missing argument)
-    2  validation error (bad name or event)
-    3  refused to overwrite an existing target, or a filesystem error
-TEXT
-
-# A small error that carries the exit code to use when it reaches the top.
-class ScaffoldError < StandardError
-  attr_reader :code
-
-  def initialize(message, code)
-    super(message)
-    @code = code
-  end
-end
-
-def fail_with(message, code)
-  raise ScaffoldError.new(message, code)
-end
-
-def validate_name!(name)
-  if name.nil? || name.empty?
-    fail_with("missing <name>. See --help for usage.", EXIT_USAGE)
-  end
-  unless name.length <= 64 && name =~ NAME_PATTERN
-    fail_with(
-      "invalid name #{name.inspect}: use lowercase letters, digits, and " \
-      "hyphens, no leading, trailing, or repeated hyphens, 1 to 64 chars.",
-      EXIT_VALIDATION
-    )
-  end
-  name
-end
-
-def validate_event!(event)
-  unless event =~ EVENT_PATTERN
-    fail_with(
-      "invalid event #{event.inspect}: use a CamelCase hook event name, " \
-      "for example PostToolUse or SessionStart.",
-      EXIT_VALIDATION
-    )
-  end
-  event
-end
-
-# Separate --out and any trailing positional dest from the bare positionals.
-# Returns [positionals, out_dir]. out_dir is nil when not given.
-def parse_args(args)
-  positionals = []
-  out_dir = nil
-  i = 0
-  while i < args.length
-    arg = args[i]
-    case arg
-    when "--out"
-      out_dir = args[i + 1]
-      if out_dir.nil?
-        fail_with("--out needs a directory argument.", EXIT_USAGE)
-      end
-      i += 2
-    else
-      if arg.start_with?("--")
-        fail_with("unknown option #{arg.inspect}. See --help for usage.", EXIT_USAGE)
-      end
-      positionals << arg
-      i += 1
-    end
-  end
-  [positionals, out_dir]
-end
-
-def refuse_if_exists!(path)
-  if File.exist?(path)
-    fail_with("refusing to overwrite existing #{path}. Remove it or pick another destination.", EXIT_CONFLICT)
-  end
-end
-
-def write_file(path, content)
-  refuse_if_exists!(path)
-  FileUtils.mkdir_p(File.dirname(path))
-  File.write(path, content)
-  puts "created #{path}"
-end
-
-# -- generators ----------------------------------------------------------
-
-def skill_body(name)
-  <<~MD
-    ---
-    name: #{name}
-    description: >
-      Use when the user needs #{name}. State here WHEN this skill should
-      trigger, in the third person, so the agent can match it. Replace this
-      placeholder with one or two concrete trigger conditions before shipping.
-    ---
-
-    # #{name}
-
-    One line on what this skill does and why it exists.
-
-    ## Gotchas
-
-    - List the non-obvious failure modes here, one per line.
-
-    ## Tasks
-
-    Keep the body slim. Route detail to references as the work earns it.
-
-    | Task | Reference |
-    | ---- | --------- |
-    | Replace this row with a real task | references/REPLACE-ME.md |
-  MD
-end
-
-def eval_stub(name)
-  data = {
-    "skill_name" => name,
-    "evals" => [
-      {
-        "id" => 1,
-        "prompt" => "",
-        "expected_output" => "",
-        "files" => [],
-        "assertions" => []
-      }
-    ]
-  }
-  JSON.pretty_generate(data) + "\n"
-end
-
-def generate_skill(name, out_dir)
-  base = File.join(out_dir, name)
-  refuse_if_exists!(base)
-  write_file(File.join(base, "SKILL.md"), skill_body(name))
-  write_file(File.join(base, "references", ".gitkeep"), "")
-  write_file(File.join(base, "evals", "evals.json"), eval_stub(name))
-  puts "skill scaffold ready at #{base}"
-end
-
-def agent_body(name)
-  <<~MD
-    ---
-    name: #{name}
-    description: >
-      Use this agent when the user needs #{name}. State here WHEN to delegate
-      to this agent, in the third person, so the orchestrator can route to it.
-      Replace this placeholder with concrete delegation conditions.
-    tools: Read, Edit, Bash
-    ---
-
-    You are the #{name} agent.
-
-    ## Responsibilities
-
-    - One line per durable responsibility this agent owns.
-
-    ## How you work
-
-    Keep this body slim. State the contract, the inputs, and the outputs.
-    Move long procedures into a references file as the work earns it.
-
-    ## Completion
-
-    End your turn with a short report of what you did and how you verified it.
-  MD
-end
-
-def generate_agent(name, out_dir)
-  write_file(File.join(out_dir, "#{name}.md"), agent_body(name))
-  puts "agent scaffold ready at #{File.join(out_dir, "#{name}.md")}"
-end
-
-def hook_body(name, event)
-  <<~RUBY
-    #!/usr/bin/env ruby
-    # frozen_string_literal: true
-
-    # #{name} - #{event} hook handler (no-op by default).
-    #
-    # This skeleton does nothing until you opt in. Set the environment flag
-    # below to a non-empty value to activate the real behavior. Until then it
-    # exits 0 so it never blocks the session.
-    #
-    # Wire it in settings.json under hooks.#{event}:
-    #   { "type": "command", "command": "ruby /absolute/path/to/#{name}" }
-    #
-    # Exit codes:
-    #   0  no-op, or success
-    #   2  block the action (only when you add real logic that should block)
-
-    OPT_IN = "#{name.tr("-", "_").upcase}_ENABLED"
-
-    if ENV[OPT_IN].nil? || ENV[OPT_IN].empty?
-      exit 0
-    end
-
-    # Opt-in is set. Add the real handler here. The hook receives event JSON on
-    # stdin; parse it only when you need it. Exit 0 to allow, exit 2 to block.
-    exit 0
-  RUBY
-end
-
-def generate_hook(name, event, out_dir)
-  path = File.join(out_dir, name)
-  write_file(path, hook_body(name, event))
-  FileUtils.chmod("+x", path)
-  puts "hook scaffold ready at #{path} (executable, #{event}, no-op until opt-in)"
-end
-
-# -- dispatch ------------------------------------------------------------
-
-def run(argv)
-  if argv.empty? || argv.include?("--help") || argv.include?("-h")
-    puts USAGE
-    return EXIT_OK
-  end
-
-  subcommand = argv.shift
-  positionals, out_flag = parse_args(argv)
-
-  case subcommand
-  when "skill", "agent"
-    name = validate_name!(positionals[0])
-    out_dir = out_flag || positionals[1] || "."
-    subcommand == "skill" ? generate_skill(name, out_dir) : generate_agent(name, out_dir)
-  when "hook"
-    # Accept "hook <name>" or "hook <Event> <name>", with an optional trailing dest.
-    if positionals.length >= 2 && positionals[0] =~ EVENT_PATTERN
-      event = validate_event!(positionals[0])
-      name = validate_name!(positionals[1])
-      out_dir = out_flag || positionals[2] || "."
-    else
-      event = DEFAULT_EVENT
-      name = validate_name!(positionals[0])
-      out_dir = out_flag || positionals[1] || "."
-    end
-    generate_hook(name, event, out_dir)
-  else
-    fail_with("unknown subcommand #{subcommand.inspect}. See --help for usage.", EXIT_USAGE)
-  end
-
-  EXIT_OK
-end
-
-begin
-  exit run(ARGV.dup)
-rescue ScaffoldError => e
-  warn "scaffold.rb: #{e.message}"
-  exit e.code
-rescue Errno::EACCES, Errno::ENOENT, Errno::EEXIST => e
-  warn "scaffold.rb: filesystem error: #{e.message}"
-  exit EXIT_CONFLICT
-end