@zalom/plastic 1.0.0-alpha.1 → 1.0.0-alpha.11

package/skills/releasing/SKILL.md

@@ -6,25 +6,62 @@ description: Use when merging a feature branch to main and tagging a release, bu
 # Releasing
 
 Merge, bump, tag, push. Annotated tags with changelogs. Semantic versioning.
+Project configuration drives the workflow — no hardcoded assumptions.
 
 ## Checklist
 
-- [ ] All tests pass
+- [ ] Read project config
+- [ ] All tests pass (or verification skipped per config)
 - [ ] Merge feature branch to main
-- [ ] Bump version in plugin.json and marketplace.json
+- [ ] Bump version in configured version files
 - [ ] Commit version bump
 - [ ] Create annotated tag
 - [ ] Push to remote with tags
+- [ ] Run post-push actions (GitHub release, npm publish, etc.)
+- [ ] Complete active intent
 
 ## Workflow
 
+### 0. Read Project Config
+
+Before anything else, determine which project we are releasing and load its config.
+
+1. Read `~/.plastic/projects.yml` — find the project whose `path` matches the current working directory.
+2. Extract the project slug (the key under `projects:`).
+3. Read `~/.plastic/projects/{slug}/project.yml` — this contains the `release:` section.
+
+Expected `release:` keys in project.yml:
+
+```yaml
+release:
+  verify: "bin/rails test"              # command to run before release
+  version_file: package.json            # single file containing the version
+  version_files:                        # multiple files (overrides version_file)
+    - package.json
+    - .claude-plugin/plugin.json
+  tag_format: "v{{version}}"            # tag naming pattern ({{version}} is replaced)
+  on_green:                             # actions to run after push succeeds
+    - github_release
+    - npm_publish
+  on_complete: commit_and_push          # what to do with the version bump commit
+  on_red: stop                          # what to do if verification fails
+```
+
+**Fallback:** If no project.yml exists or it has no `release:` section, fall back to asking the user for each step — verify command, version files, tag format, and post-push actions.
+
 ### 1. Verify Tests Pass
 
+Run the verification command from `release.verify` in project.yml:
+
 ```bash
-ruby test/read_config_test.rb && ruby test/config_template_test.rb
+# Example: release.verify = "ruby -Itest test/*_test.rb"
+<verify-command-from-config>
 ```
 
-All tests must pass before release. Do not proceed if any fail.
+- If `release.verify` is present: run it. All checks must pass before proceeding.
+- If `release.verify` is absent or empty: skip verification. Log that no verify command is configured.
+- If `release.on_red` is `stop`: abort the release on failure.
+- If `release.on_red` is `fix_and_retry`: ask the user to fix and re-run.
 
 ### 2. Determine Version Bump
 
@@ -47,18 +84,26 @@ Always `--no-ff` to preserve branch history in the merge commit.
 
 ### 4. Bump Version
 
-Update ALL THREE files — they must stay in sync:
-- `package.json` → `"version": "X.Y.Z"`
-- `.claude-plugin/plugin.json` → `"version": "X.Y.Z"`
-- `.claude-plugin/marketplace.json` → `"version": "X.Y.Z"`
+Determine which files to update from project.yml:
+
+- If `release.version_files` is set: update ALL listed files (they must stay in sync).
+- Else if `release.version_file` is set: update that single file.
+- Else: ask the user which files contain the version.
+
+Update the version string in each file, then commit:
 
 ```bash
-git add package.json .claude-plugin/plugin.json .claude-plugin/marketplace.json
+git add <version-files>
 git commit -m "chore: bump version to X.Y.Z — [one-line summary]"
 ```
 
 ### 5. Create Annotated Tag
 
+Read `release.tag_format` from project.yml to determine the tag name:
+
+- If set (e.g. `"v{{version}}"`): replace `{{version}}` with the new version string.
+- If not set: default to `vX.Y.Z`.
+
 Generate the changelog from commits since the last tag:
 
 ```bash
@@ -68,7 +113,7 @@ git log $(git describe --tags --abbrev=0)..HEAD --oneline --no-merges | grep -E
 Create the tag with a multi-line message:
 
 ```bash
-git tag -a vX.Y.Z -m "vX.Y.Z — [release name]
+git tag -a <tag-name> -m "<tag-name> — [release name]
 
 - [changelog bullet points from feat/fix/refactor commits]"
 ```
@@ -79,16 +124,42 @@ git tag -a vX.Y.Z -m "vX.Y.Z — [release name]
 git push origin main --tags
 ```
 
-### 7. GitHub Release
+### 7. Post-Push Actions
+
+Read `release.on_green` from project.yml. This is a list of actions to run after a successful push. Execute each in order:
 
-Create a GitHub release from the tag. Use `--generate-notes` to auto-generate changelog from commits since the previous tag:
+#### `github_release`
+
+Create a GitHub release from the tag:
 
 ```bash
-gh release create vX.Y.Z --title "vX.Y.Z — [release name]" --generate-notes --notes-start-tag <previous-tag>
+gh release create <tag-name> --title "<tag-name> — [release name]" --generate-notes --notes-start-tag <previous-tag>
 ```
 
 For the first release (no previous tag), write notes manually with `--notes "..."` instead.
 
+#### `npm_publish`
+
+Publish the package to npm:
+
+```bash
+# For pre-release versions (0.x.y, or version contains -alpha/-beta/-rc):
+npm publish --access public --tag alpha
+
+# For stable versions (>= 1.0.0, no pre-release suffix):
+npm publish --access public
+```
+
+#### Other values
+
+If `on_green` contains an action not listed above, log it:
+
+```
+[releasing] Action "<action>" is configured but not yet implemented. Skipping.
+```
+
+If `on_green` is empty or absent: skip post-push actions entirely.
+
 ### 8. Complete Active Intent
 
 A release IS a delivery. The active intent that drove this work must be completed as part of the release process. This is NOT optional.
@@ -100,17 +171,17 @@ A release IS a delivery. The active intent that drove this work must be complete
    c. Update `## Insights` with final observations
    d. Move from `## Active` to `## Completed` in INDEX.md (with today's date)
    e. Update clusters to show `_(completed)_`
-3. Auto-commit: `cd ~/.plastic && git add . && git commit -m "feat: complete intent <ID> — delivered in v<X.Y.Z>"`
+3. Auto-commit: `cd ~/.plastic && git add . && git commit -m "feat: complete intent <ID> — delivered in <tag-name>"`
 
 **If no active intent exists for this release**, that itself is a problem — work happened outside the intent system. Log it and move on, but flag it.
 
 ## Conventions
 
 - **Annotated tags only** — `git tag -a`, never lightweight tags
-- **Tag format** — `vX.Y.Z` (lowercase v prefix)
-- **Tag message** — first line: `vX.Y.Z — [short name]`, then blank line, then bullet changelog
+- **Tag format** — driven by `release.tag_format` in project.yml (default: `vX.Y.Z`)
+- **Tag message** — first line: `<tag> — [short name]`, then blank line, then bullet changelog
 - **Commit prefixes** — `feat:`, `fix:`, `refactor:`, `chore:`, `docs:` (conventional commits)
-- **Version files** — package.json, plugin.json, and marketplace.json always match
+- **Version files** — driven by project.yml; all listed files must always match
 - **Branch cleanup** — delete merged feature branches: `git branch -d <branch>`
 
 ## Retroactive Tagging
@@ -122,3 +193,7 @@ git tag -a v0.1.0 <commit-sha> -m "v0.1.0 — [description]"
 ```
 
 Use `git log --oneline` to find the right commits (look for version bump commits or major feature merges).
+
+## References
+
+- Read `references/deprecations.md` for the full deprecation process, severity levels, deprecations.yml schema, and dismissal rules when adding or managing deprecations

package/skills/releasing/references/deprecations.md

@@ -0,0 +1,44 @@
+# Deprecation Process
+
+When removing a feature, changing a convention, or making a breaking change:
+
+1. Add entry to `deprecations.yml` in the Plastic source root
+2. Set severity: `info` (awareness), `warning` (action needed), `critical` (urgent)
+3. Provide clear migration steps
+4. Set `removal` version at least 2 minor versions ahead
+5. SessionStart hook displays active deprecations automatically
+6. Remove the feature AND the deprecation entry together
+
+## Severity Levels
+
+| Severity | When to use | Dismissable? |
+|----------|-------------|--------------|
+| `info` | Upcoming change | Yes |
+| `warning` | Action needed | Yes (re-shown at removal) |
+| `critical` | Urgent/security | Never |
+
+## deprecations.yml Schema
+
+```yaml
+deprecations:
+  - id: unique-slug
+    severity: info | warning | critical
+    summary: "One-line description"
+    migration_steps:
+      - "Step 1"
+      - "Step 2"
+    introduced: "0.9.0"
+    removal: "1.0.0"
+    link: "optional URL"
+```
+
+## Dismissal
+
+Users dismiss by adding the id to `deprecations_dismissed` in `config.yml`:
+
+```yaml
+deprecations_dismissed:
+  - some-deprecated-feature
+```
+
+Critical deprecations and final-version warnings ignore dismissal.

package/skills/research/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: plastic:research
+description: "Research a topic for the active intent. Agent decides shallow vs deep based on scope. Produces reports in the intent's resources/ directory."
+---
+
+# Research
+
+Investigate a topic related to the active intent. Choose the right depth, produce a cited report.
+
+**Announce at start:** "I'm researching [topic] for intent {id} — {name}."
+
+## 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`. If exactly one → use it. If multiple → ask which. If none → refuse: "No active intent. Create one first with /plastic:creating-intent"
+3. **Resolve intent directory:** `{store}/store/{id}--{slug}/`
+
+## Depth Decision
+
+Before starting research, assess the question against these criteria:
+
+### Shallow Research
+Use when:
+- The question is narrow and factual (e.g., "what's the API for X?", "does library Y support Z?")
+- A single source or quick search is sufficient
+- The answer is likely well-documented
+- Time budget: minutes, not hours
+
+**Method:** Direct web search + codebase exploration + single-pass synthesis.
+
+### Deep Research
+Use when:
+- The question needs multiple sources and cross-verification
+- It's a landscape survey, competitive analysis, or architectural decision
+- The user explicitly asks for thorough/exhaustive/comprehensive research
+- Conflicting information exists and needs adversarial verification
+- Time budget: significant, user expects depth
+
+**Method:** Delegate to the native agent's deep research capability.
+- On Claude Code: invoke the `deep-research` skill via `Skill` tool
+- On other agents: use the agent's equivalent (see intent 7 for cross-agent mapping)
+- If no native deep research exists: fan out multiple web searches manually, cross-reference, synthesize
+
+### Decision Heuristic
+
+Ask yourself:
+1. Can I answer this with 1-2 searches? → **Shallow**
+2. Do I need to compare 3+ sources? → **Deep**
+3. Is the user asking for a survey or landscape view? → **Deep**
+4. Am I fact-checking a specific claim? → **Shallow**
+5. Could wrong information here cause architectural mistakes? → **Deep**
+
+Announce your choice: "This needs [shallow/deep] research because [reason]."
+
+## Output
+
+### File Location
+`{intent_dir}/resources/{type}--{topic}.md`
+
+Create the resources/ directory if it doesn't exist.
+
+### Naming Convention
+- `{type}` — one of: `deep-research`, `competitive-analysis`, `technical-spike`, `reference`, `landscape-survey`
+- `{topic}` — kebab-case description of the research subject
+
+Examples:
+- `deep-research--installer-patterns.md`
+- `technical-spike--sqlite-vec-performance.md`
+- `reference--claude-code-hooks-api.md`
+- `landscape-survey--ai-agent-ecosystem.md`
+
+### Report Structure
+
+```markdown
+# {Type}: {Topic}
+
+**Intent:** {id} — {name}
+**Depth:** shallow | deep
+**Date:** YYYY-MM-DD
+
+## Summary
+[2-3 sentence executive summary]
+
+## Findings
+
+### [Finding 1 title]
+[Details with inline citations where applicable]
+
+### [Finding 2 title]
+...
+
+## Sources
+- [Source 1 title](url) — what was learned from this source
+- [Source 2 title](url) — ...
+
+## Relevance to Intent
+[How these findings affect the active intent's decisions or design]
+```
+
+## After Research
+
+1. Commit to store repo:
+   ```
+   cd {store_root} && git add . && git commit -m "research: {type} — {topic} (intent {id})"
+   ```
+
+2. Log in intent's `## Insights`:
+   ```
+   - Research: {type} — {topic}. Key finding: [one sentence]. See resources/{filename}.
+   ```
+
+3. Research does NOT chain to any other skill. It's a side quest — the user decides what to do with the findings.

package/skills/savepoint/SKILL.md

@@ -55,3 +55,7 @@ git commit -m "chore: savepoint — [active intent name]"
 
 ### 5. Notify User
 Tell the user: "Context is getting large. I've saved progress to intent [ID] — [name]. Please run `/clear` and say `continue` to resume."
+
+## References
+
+- Read `references/context-management.md` for the full save/continue protocol when the save flow needs debugging or you need to understand the full resume sequence

package/skills/savepoint/references/context-management.md

@@ -0,0 +1,32 @@
+# Context Management (Start-Save-Continue)
+
+## Save Point
+Triggered by PreCompact hook or manually:
+1. Find active intent(s) from `~/.plastic/INDEX.md`
+2. Update active intent's `checklist.md` (check off completed items)
+3. Update active intent's `savepoint.md` (in-progress, next steps, blockers, discoveries)
+4. Add observations to `## Insights`
+5. Update INDEX.md
+6. Commit: `cd ~/.plastic && git add . && git commit -m "chore: savepoint — [intent name]"`
+7. Notify user to `/clear`
+
+## Continue
+Triggered by UserPromptSubmit hook when user says "continue". Priority order:
+
+**1. Active intents first (resume work):**
+1. Read INDEX.md → find active intent(s)
+2. Read active intent's `intent.md` → what and why
+3. Read active intent's `savepoint.md` → where we left off
+4. Read active intent's `checklist.md` → what's next
+5. Announce: intent name, current state, next step, blockers
+6. Resume
+
+**2. No active intents → offer future intents:**
+1. List all future intents from INDEX.md
+2. Present them as options
+3. When user picks one, move to Active in INDEX.md
+
+**3. Stale future intents (untouched 3+ days) → triage:**
+- **activate** — start working on it now
+- **abandon** — mark as abandoned
+- **defer to agent** — implement, research, or ideate

package/skills/update/SKILL.md

@@ -54,13 +54,21 @@ Key changes in this version:
 Recommendation: run /clear for a clean session with all new conventions loaded.
 ```
 
-### Step 4: Commit
+### Step 4: Run health check
+
+Invoke `plastic:doctor` to verify the installation is healthy after the update.
+
+If all checks pass, show: **"Health check: all clear."**
+
+If issues are found, show the full doctor report and offer to fix any fixable items.
+
+### Step 5: Commit
 
 ```bash
 cd ~/.plastic && git add PLASTIC.md scripts/ AGENTS.md VERSION 2>/dev/null && git commit -m "chore: update Plastic core files" --allow-empty
 ```
 
-### Step 5: Clear update cache
+### Step 6: Clear update cache
 
 ```bash
 rm -f ~/.plastic/.cache/update-check.json

package/skills/writing-instructions/SKILL.md

@@ -0,0 +1,159 @@
+---
+name: writing-instructions
+description: >
+  Write or restructure agent instructions, conventions files, and SKILL.md
+  content using progressive disclosure and the agentskills.io specification.
+  Use when creating PLASTIC.md, rewriting convention docs, authoring new
+  skills, restructuring large instruction files to fit context budgets,
+  or when instructions feel too long, too vague, or agents aren't following
+  them. Also use when the user says "progressive disclosure", "restructure
+  instructions", or "the instructions are too big".
+---
+
+# Writing Agent Instructions
+
+Based on the [agentskills.io specification](https://agentskills.io).
+
+## Progressive Disclosure Architecture
+
+All agent instructions follow three loading stages. Design for this — it's the
+architecture, not a nice-to-have.
+
+| Stage | What loads | Budget | Design for |
+|-------|-----------|--------|------------|
+| **Discovery** | name + description | ~100 tokens | Trigger accuracy |
+| **Activation** | Full instruction body | <5000 tokens / <500 lines | Core procedures |
+| **Execution** | references/, scripts/, assets/ | As needed | Deep detail |
+
+**The description carries the entire burden of triggering.** If agents aren't
+activating your skill, the description is the problem.
+
+## Procedure
+
+### Step 1: Audit the content
+
+Before writing or restructuring, classify every piece of content:
+
+| Classification | Where it goes | Example |
+|---------------|---------------|---------|
+| **Trigger context** | description field | "Use when...", keywords |
+| **Core procedure** | SKILL.md body | Step-by-step workflows |
+| **Gotchas** | SKILL.md body (early) | Facts that defy assumptions |
+| **Deep reference** | references/ | API details, full schemas |
+| **Templates** | assets/ or inline | Output format examples |
+| **Executable logic** | scripts/ | Validation, data processing |
+
+Ask for each piece: "Would the agent get this wrong without this?"
+If no — cut it. If unsure — test it.
+
+### Step 2: Write the description
+
+The description must convey WHEN to use, not just WHAT it does.
+
+**Rules:**
+- Imperative phrasing: "Use this skill when..." not "This skill does..."
+- Focus on user intent, not implementation
+- Err on the side of being pushy — list contexts explicitly
+- Include cases where user doesn't name the domain directly
+- Under 1024 characters (hard limit)
+- Include specific trigger keywords
+
+**Template:**
+```yaml
+description: >
+  [One sentence: what it does]. Use when [primary trigger context],
+  [secondary trigger], or when [indirect trigger where user doesn't
+  name the domain]. Also use when [edge case trigger].
+```
+
+### Step 3: Write the body
+
+**Principles (in priority order):**
+
+1. **Procedures over declarations** — Teach HOW to approach a class of problems,
+   not WHAT to produce for a specific instance
+2. **Defaults, not menus** — Pick one approach, mention alternatives briefly.
+   "Use X. For Y cases, use Z instead." Never present options as equals.
+3. **Calibrate control to fragility** — Prescriptive for fragile/sequential tasks,
+   flexible when multiple approaches are valid. Most skills have a mix.
+4. **Reasoning over rigid directives** — "Do X because Y tends to cause Z" beats
+   "ALWAYS do X, NEVER do Y"
+5. **Add what the agent lacks, omit what it knows** — No explaining HTTP, PDFs,
+   or what a migration is. Jump to what's non-obvious.
+
+**Structure:**
+```markdown
+# Title
+
+[1-2 sentence purpose statement]
+
+## Gotchas
+- [Highest-value content first — facts that defy assumptions]
+- [Each gotcha is a concrete correction, not general advice]
+
+## Procedure
+### Step 1: ...
+### Step 2: ...
+
+## Patterns
+[Only if the skill covers multiple approaches to similar problems]
+```
+
+### Step 4: Extract to references/
+
+Anything over 500 lines or 5000 tokens goes to `references/`. But tell the
+agent WHEN to load each file — conditional references, not a generic "see
+references/ for details."
+
+**Good:** "Read `references/api-errors.md` if the API returns a non-200 status"
+**Bad:** "See references/ for more information"
+
+### Step 5: Validate
+
+Run through this checklist:
+
+- [ ] Description under 1024 chars
+- [ ] Body under 500 lines / 5000 tokens
+- [ ] Every instruction passes "would the agent get this wrong without it?"
+- [ ] Gotchas are concrete corrections, not general advice
+- [ ] Defaults chosen, not menus presented
+- [ ] Control calibrated: prescriptive where fragile, flexible where tolerant
+- [ ] References have conditional load triggers
+- [ ] No explaining what the agent already knows
+
+For structured evaluation beyond this checklist (paired evals, pass rate
+tracking, regression testing), use `plastic:evaluating-skills`.
+
+## Gotchas
+
+- Hook `additionalContext` truncates at **10,000 characters**. If instructions
+  must load via hooks (not skills), they must fit this budget.
+- `~/.claude/rules/*.md` files load fully with no truncation — use for
+  always-loaded conventions that don't fit in a skill.
+- CLAUDE.md supports `@path/to/file` imports (max depth 4) — another way
+  to load large instruction sets without truncation.
+- Agents only consult skills for tasks beyond what they can handle alone.
+  Simple one-step requests may not trigger even with a perfect description.
+- Content from real domain expertise (runbooks, incident reports, code review)
+  dramatically outperforms LLM-generated instructions without project context.
+- The most common cause of agents not following instructions: the instruction
+  was too vague, didn't apply to the current task, or presented too many
+  options without a clear default. Read execution traces to diagnose.
+
+## For Convention Files (PLASTIC.md, CLAUDE.md)
+
+Convention files aren't skills — they load differently. Apply progressive
+disclosure by splitting:
+
+| Layer | Mechanism | Budget | Content |
+|-------|-----------|--------|---------|
+| **Always-on** | `~/.claude/rules/` or hook | <10K chars | Core identity, gotchas, critical procedures |
+| **On-demand** | Skills (SKILL.md) | <5K tokens each | Specific workflows activated by task |
+| **Deep reference** | `references/` in skills | Unlimited | Full specs, schemas, examples |
+
+**The always-on layer should answer: "What does this agent need to know about
+every single task?"** Everything else activates on demand.
+
+## References
+
+- Read `references/agentskills-spec.md` for the complete agentskills.io specification including frontmatter fields, description optimization methodology, evaluation framework, and script design requirements