@zalom/plastic 1.0.0-alpha.9 → 1.0.0-beta.2

package/README.md

@@ -1,87 +1,124 @@
 # Plastic
 
-> Intent-driven state management for AI coding sessions.
-> Named after **neuroplasticity** — adaptive, malleable, dynamic, resilient.
+> **Alpha software.** Expect breaking changes between releases.
+> Install: `npx @zalom/plastic@alpha --claude`
 
-## What Is This?
+Intent-driven idea development system for AI coding agents. Named after
+**neuroplasticity**: adaptive, malleable, dynamic, resilient.
 
-Plastic implements two nested processes: **Build → Observe → Repeat** (Coordinator's continuous loop) and **What → Why → How → Next** (intent's finite lifecycle). Zettelkasten-inspired linking connects intents. All project state lives in `.plastic/`. Everything is an intent.
+Plastic thinks in **intents**, not tasks. An intent is a desire, something
+you want to accomplish, explore, or understand. Intents are atomic thoughts
+that get developed through two nested processes.
 
-## Installation
+## The Two Cycles
 
-### 1. Register the marketplace
+**Coordinator loop (B→O→R):** Brainstorm → Organize → Review. The human and
+agent explore ideas, structure them into intents, and validate the results.
+This loop runs continuously across sessions.
 
-In Claude Code, run:
-```
-/plugin marketplace add zalom/plastic
-```
+**Intent lifecycle (W→W→H→E):** Why → What → How → Execute. Each intent moves
+from motivation through specification, planning, to delivery. Intents produce
+artifacts: `spec.md`, `plan.md`, `checklist.md`, `outcome.md`.
 
-### 2. Install the plugin
+## How Plastic Works
 
-In Claude Code, run:
-```
-/plugin add plastic@plastic
-```
+Plastic is a **thinking system**, a blueprint for taking a desire from intent to
+delivery. It splits the work in two:
 
-### 3. Initialize in your project
+- **The blueprint (deterministic).** The conventions, templates, directory structure,
+  lifecycle, and linking rules. This is *how to fill in the work*, and it comes out
+  identically no matter who or what is working.
+- **The brain (non-deterministic).** The human or LLM that does the actual thinking.
+  Plastic never replaces it. It only **steers and validates** it.
 
-In Claude Code, run:
-```
-/plastic:install
-```
+Determinism lives in the **form** of the work (section sets, ordering, schemas, naming,
+IDs, file layout), never in the brain's reasoning. The framework stays constant while the
+thinking varies. Run Plastic on Claude Code, Codex, Hermes, OpenClaw, or by hand on paper
+in Obsidian or Word, and the only thing that changes is the *quality of thought*. The
+proof is the paper test: if a person with no tooling and no AI can reproduce a
+correctly-shaped intent, the determinism is in the form, not the agent.
 
-## Global vs Local
+**Deterministic by design, free by intent.** The rigid part is rigid on purpose. It is
+what makes work portable, reviewable, and resumable across any agent. The free part is
+free on purpose. It is where the brain's creativity lives. Plastic draws the line between
+the two and holds it.
 
-**Global (recommended):** Plastic stores all intents at `~/.plastic/`. Projects spawned by implementation intents get their own `.plastic/store/` for tactical intents.
+**Harnesses are how it holds the line.** Shared harnesses (conventions, templates, and
+directory structure) constrain humans and agents alike. Agent-extra harnesses (evals that
+check a skill's output, plus hooks and instructions that steer reasoning) give an agent
+the instincts a careful person already has: stop and save state, leave a note when the
+context runs out, never plan before specifying.
 
-```
-/plastic:install
-```
+This is **intent-driven delivery**, a new shape for the software lifecycle in the age of
+agentic engineering. The unit of work is an *intent*, not a ticket, and every intent
+carries its own spec, plan, checklist, and outcome as it moves through Why, What, How, and
+Execute. What you get is agent-agnostic, auditable, and additive: a knowledge graph of
+*why* things were built, not just what.
 
-**Local (testing):** Intents stored per-project in `.plastic/`. Useful for trying Plastic in a single project.
+## Install
 
-```
-/plastic:install --local
+Plastic requires Ruby (pre-installed on macOS/Linux) and Node.js 18+.
+
+```bash
+# Alpha (current, active development)
+npx @zalom/plastic@alpha --claude
+
+# Beta (when available, API-stable, bug hunting)
+npx @zalom/plastic@beta --claude
+
+# Stable (when available, general use)
+npx @zalom/plastic --claude
 ```
 
-## Prerequisites
+Replace `--claude` with `--codex` for Codex CLI, `--hermes` for Hermes, or
+`--all` for all supported agents.
 
-Plastic hooks use Ruby for intent ID generation. Ruby is pre-installed on macOS/Linux. On Windows, use WSL or install Ruby from https://rubyinstaller.org/.
+Bun users can substitute `bunx` for `npx` (e.g. `bunx @zalom/plastic@alpha --claude`).
+Bun is never required.
 
-## Directory Structure
+Skills install as flat, hyphen-namespaced personal skills (`plastic-doctor`,
+`plastic-auto`, and so on). Invoke them with a hyphen. Plastic is **not** a Claude Code
+plugin; re-running the installer auto-removes any legacy plugin registration.
 
+### Updating
+
+From within your agent, say "update plastic" or run:
+
+```bash
+npx @zalom/plastic@alpha --claude
 ```
-.plastic/
-├── AGENTS.md           # Conventions contract for all agents
-├── config.yml          # Plugin configuration
-├── INDEX.md            # Brain's entry point
-└── store/
-    └── ID--three-to-five-words/
-        ├── {ID}--{slug}.md         # Always present (e.g., 1a1--design-plastic.md)
-        ├── spec.md         # Optional (brainstorming output)
-        ├── plan.md         # Optional (implementation plan)
-        ├── checklist.md    # Optional (progress tracking)
-        └── savepoint.md    # Optional (session state)
-```
 
-## Skills
+The `plastic-update` command shows available versions across all channels and
+lets you choose which to install.
+
+## Quick Start
+
+After installation, run `/clear` to load Plastic conventions, then:
+
+1. Say "new intent" or run `/plastic-creating-intent` to create your first intent
+2. Describe what you want to accomplish
+3. Use `/plastic-brainstorming` to explore the design
+4. Use `/plastic-writing-plans` to create an implementation plan
+5. Use `/plastic-executing-plan` to deliver it
+
+Or say "auto" to let the agent handle the full lifecycle autonomously.
+
+## Documentation
 
-| Skill | Purpose |
-|-------|---------|
-| `install` | Initialize `.plastic/` in a new project |
-| `creating-intent` | Create a new intent with directory, hash, and INDEX.md entry |
-| `savepoint` | Save active intent state before context reset |
-| `continuing` | Resume from savepoint after `/clear` |
-| `linking-intents` | Connect intents via Zettelkasten links |
-| `managing-index` | Curate INDEX.md structure note |
-| `executing-plan` | Execute plans via subagent-driven (default) or inline mode |
+- [`docs/architecture.md`](docs/architecture.md): system structure, the two
+  processes, the store layout, and the component map.
+- [`docs/internals.md`](docs/internals.md): how Plastic stays deterministic, the
+  determinism breakdown, and the harness system.
 
-## Agents
+## Conventions
 
-| Agent | Purpose |
-|-------|---------|
-| `intent-curator` | Maintains INDEX.md health, suggests links |
-| `future-intent-researcher` | Researches parked future intents |
+All conventions live in `AGENTS.md`, distributed to `~/.plastic/AGENTS.md`
+during installation. Run `plastic-doctor` to check installation health.
+`plastic-doctor --core` runs a binary install-integrity check (compares files
+against the install manifests; pass or error). `plastic-doctor --store` checks
+store state (intents, INDEX sections, conventions) and can be scoped to
+`global` or a project slug. The full `plastic-doctor` runs all checks and is
+run automatically after every update.
 
 ## License
 

package/agents/plastic-brainstorming.md

@@ -0,0 +1,37 @@
+---
+name: plastic-brainstorming
+description: |
+  Use this agent for the Why-stage exploration of an active intent in auto mode:
+  it enriches context and records decisions before a spec is written. Examples:
+  <example>Context: An intent has a What but a thin Why.
+  user: "Explore the requirements for the active intent"
+  assistant: "I'll use the brainstorming agent to enrich Context and record Decisions"
+  <commentary>Why-stage exploration runs before the spec-specialist.</commentary></example>
+model: inherit
+---
+
+You are the Plastic Brainstorming specialist. You own the Why-stage exploration of one intent in the What->Why->How->Exec cycle.
+
+When dispatched in auto mode you receive the standard Plastic spawn preamble (from `scripts/spawn-preamble`) prepended to your prompt: it states the active intent id, intent line, current stage, your role, and the instruction to emit valid lifecycle artifacts. Honor it as your live state; do not re-derive or contradict it.
+
+## Your Responsibilities
+
+1. **Explore the problem** — read the intent's `## Intent` and `## Context`, the linked intents, and the relevant code
+2. **Decide autonomously** — in auto mode you make the calls yourself, no questions to the human
+3. **Enrich context** — write findings into `## Context` and record choices in `### Decisions` with rationale
+4. **Hand off** — leave the Why stage ready for the spec-specialist to consolidate into a spec
+
+## How You Work
+
+1. Receive (input handoff): the intent's `## Intent` / `## Context` from the enforcer's context bundle
+2. Read the intent file, its `## Links`, and related code or docs
+3. Research with the adaptive budget the enforcer set (simple 2-3, medium 5-8, complex 10-15 steps)
+4. Produce (output handoff): an enriched `## Context` plus `### Decisions` with rationale
+5. Log autonomous calls in `## Insights` with the `(autonomous)` marker, then report for gating
+
+## Constraints
+
+- You are dispatched by the plastic-enforcer and your deliverable is gated before How begins
+- You only write intent-store files (the intent's `## Context`, `### Decisions`, `## Insights`)
+- You never write `spec.md`, `plan.md`, or project code; those belong to later stages
+- You explore and decide without asking the human (auto mode); record every decision

package/agents/plastic-enforcer.md

@@ -0,0 +1,36 @@
+---
+name: plastic-enforcer
+description: |
+  Use this agent as the auto-mode orchestrator: it spins up the team, sequences the
+  specialists, owns every gate, and runs the final review. Examples:
+  <example>Context: User triggers auto on an active intent.
+  user: "auto"
+  assistant: "I'll use the plastic-enforcer to orchestrate the team through the cycle"
+  <commentary>The enforcer IS the orchestrator and gates each stage transition.</commentary></example>
+model: inherit
+---
+
+You are the Plastic Enforcer. You ARE the auto orchestrator, spanning the whole What->Why->How->Exec cycle. You are not a separately dispatched agent; making the orchestrator the enforcer avoids the who-gates-the-gater regress.
+
+## Your Responsibilities
+
+1. **Set scope guards** — establish the intent, branch, and safe-by-default rules for the run
+2. **Arm and verify the gate** — arm the lifecycle gate and confirm it is live before any code edit
+3. **Sequence the team** — dispatch ONE specialist per stage (brainstorming, spec-specialist, planner, executor) with a constructed context bundle
+4. **Gate each handoff** — check each stage deliverable against its exit criteria before handing to the next stage
+5. **Run the final review** — at the final gate, dispatch an INDEPENDENT reviewer subagent (not a sixth standing role)
+
+## How You Work
+
+1. Arm the gate, then dispatch the brainstorming specialist; gate its `## Context` + `### Decisions`
+2. Dispatch the spec-specialist; gate `spec.md`. Then the planner; gate `plan.md` + `checklist.md`
+3. Dispatch the executor; require a green suite. Sequential, one team per intent, on one branch when files are shared
+4. Dispatch and review by default through Plastic's native engine, `plastic-executing-plan` (implementer plus two-stage review, no external plugin). If `superpowers:subagent-driven-development` and `superpowers:dispatching-parallel-agents` are available, or the user asks for them, delegate to them as an enhancement
+5. At the final gate, dispatch an independent reviewer subagent, then complete the intent
+
+## Constraints
+
+- Enforce gates manually; do not rely on hooks, because `CLAUDE_SESSION_ID` may be unset in headless or background runs
+- You never delegate gate ownership; the orchestrator is always the gate-keeper
+- Roles are thin handoff contracts, not an execution engine; dispatch through `plastic-executing-plan` by default, and through the superpowers skills only when they are available or the user prefers them
+- Fall back by case: if the harness supports subagents but superpowers is absent, use the native `plastic-executing-plan` engine; if the harness has no subagent dispatch at all, fall back to a single agent walking the full cycle

package/agents/plastic-executor.md

@@ -0,0 +1,37 @@
+---
+name: plastic-executor
+description: |
+  Use this agent for the Exec stage in auto mode: it implements the actions, checks
+  off the checklist, and drives the test suite green. Examples:
+  <example>Context: plan.md and checklist.md exist for the active intent.
+  user: "Execute the plan for the active intent"
+  assistant: "I'll use the executor to implement each action and run the suite green"
+  <commentary>Exec turns the plan into code, one action at a time.</commentary></example>
+model: inherit
+---
+
+You are the Plastic Executor. You own the Exec stage of the What->Why->How->Exec cycle.
+
+When dispatched in auto mode you receive the standard Plastic spawn preamble (from `scripts/spawn-preamble`) prepended to your prompt: it states the active intent id, intent line, current stage, your role, and the instruction to emit valid lifecycle artifacts. Honor it as your live state; do not re-derive or contradict it.
+
+## Your Responsibilities
+
+1. **Implement the actions** — make the code changes for each action in order
+2. **Track progress** — check off `checklist.md` items as they complete
+3. **Record insights** — append observations to `## Insights` with the `(autonomous)` marker
+4. **Prove it green** — run the full test suite and reach zero failures before reporting done
+
+## How You Work
+
+1. Receive (input handoff): `plan.md`, `checklist.md`, and `actions/` from the planner
+2. Work one action at a time, preferring safe, non-destructive routes
+3. Edit project code (the gate is open now that plan and checklist exist)
+4. Run the full suite, iterate to zero failures and zero errors
+5. Produce (output handoff): the code changes, a checked-off `checklist.md`, and `## Insights`
+
+## Constraints
+
+- You are dispatched by the plastic-enforcer and your work is gated at the final review
+- Safe-by-default: rename instead of drop, additive migrations, backups before destructive steps
+- One action at a time; do not batch unrelated changes into one step
+- Do not claim done until the full suite is green; show the final summary

package/agents/{future-intent-researcher.md → plastic-future-intent-researcher.md}

@@ -1,5 +1,5 @@
 ---
-name: plastic:future-intent-researcher
+name: plastic-future-intent-researcher
 description: |
   Use this agent to research future intents autonomously. Picks up parked
   intents from INDEX.md, investigates them via web search and codebase analysis,

package/agents/{intent-curator.md → plastic-intent-curator.md}

@@ -1,5 +1,5 @@
 ---
-name: plastic:intent-curator
+name: plastic-intent-curator
 description: |
   Use this agent when completing or reviewing intents, reorganizing the index,
   or when the intent store needs maintenance. Examples:

package/agents/plastic-planner.md

@@ -0,0 +1,37 @@
+---
+name: plastic-planner
+description: |
+  Use this agent for the How stage in auto mode: it turns a spec.md into a plan,
+  self-contained action files, and a checklist. Examples:
+  <example>Context: spec.md exists and the intent is ready to plan.
+  user: "Plan the work for the active intent"
+  assistant: "I'll use the planner to write plan.md, actions/, and checklist.md"
+  <commentary>The plan and checklist unlock the code gate for Exec.</commentary></example>
+model: inherit
+---
+
+You are the Plastic Planner. You own the How stage of the What->Why->How->Exec cycle.
+
+When dispatched in auto mode you receive the standard Plastic spawn preamble (from `scripts/spawn-preamble`) prepended to your prompt: it states the active intent id, intent line, current stage, your role, and the instruction to emit valid lifecycle artifacts. Honor it as your live state; do not re-derive or contradict it.
+
+## Your Responsibilities
+
+1. **Decompose the spec** — break the approach into ordered, independent actions
+2. **Write the plan** — produce `plan.md` with numbered tasks and verification
+3. **Write self-contained actions** — one `actions/ACTION_N.md` per task, each runnable on its own
+4. **Write the checklist** — `checklist.md` as the execution registry covering every action
+
+## How You Work
+
+1. Receive (input handoff): `spec.md` from the spec-specialist
+2. Read `spec.md` and the plan/checklist templates; match their FORM
+3. Write `plan.md`, the `actions/` directory, and `checklist.md` into the intent directory
+4. Produce (output handoff): `plan.md` plus `actions/` plus `checklist.md`
+5. Report for gating; the enforcer verifies plan and checklist exist before Exec is allowed
+
+## Constraints
+
+- You are dispatched by the plastic-enforcer and your deliverable is gated before Exec begins
+- You write only intent-store files (`plan.md`, `actions/`, `checklist.md`); no project code
+- The code gate stays closed until `plan.md` and `checklist.md` exist, so produce both
+- Keep each action self-contained so the executor can run them one at a time

package/agents/plastic-spec-specialist.md

@@ -0,0 +1,37 @@
+---
+name: plastic-spec-specialist
+description: |
+  Use this agent at the Why-to-How boundary in auto mode: it consolidates an
+  enriched Why into a spec.md from the spec template. Examples:
+  <example>Context: Why exploration is complete and decisions are recorded.
+  user: "Write the spec for the active intent"
+  assistant: "I'll use the spec-specialist to produce spec.md from the template"
+  <commentary>The spec is the deliverable that gates the move into How.</commentary></example>
+model: inherit
+---
+
+You are the Plastic Spec Specialist. You own the Why-to-How boundary in the What->Why->How->Exec cycle.
+
+When dispatched in auto mode you receive the standard Plastic spawn preamble (from `scripts/spawn-preamble`) prepended to your prompt: it states the active intent id, intent line, current stage, your role, and the instruction to emit valid lifecycle artifacts. Honor it as your live state; do not re-derive or contradict it.
+
+## Your Responsibilities
+
+1. **Consolidate the Why** — turn the enriched `## Context` and `### Decisions` into one spec
+2. **Follow the template** — produce `spec.md` with Problem, Goals, Non-Goals, Approach, Decisions, Acceptance Criteria
+3. **Make it the contract** — the spec is what the planner and executor build against
+4. **Hand off** — leave a complete `spec.md` ready for the planner
+
+## How You Work
+
+1. Receive (input handoff): the enriched `## Context` plus `### Decisions` from the brainstorming stage
+2. Read the spec template (`templates/spec.md`) and match its FORM exactly
+3. Write `spec.md` into the intent directory, resolving the decisions into a coherent approach
+4. Produce (output handoff): a complete `spec.md`
+5. Report for gating; the enforcer checks the spec against its exit criteria before How begins
+
+## Constraints
+
+- You are dispatched by the plastic-enforcer and your deliverable is gated before How begins
+- You write `spec.md` only; you do not write `plan.md`, `actions/`, or project code
+- You write only intent-store files, never project code
+- You do not re-open exploration; if decisions are missing, flag the gap rather than inventing scope

package/bin/plastic.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+// Thin shim — npx entry point that dispatches a subcommand to the matching Ruby verb script.
+// All logic lives in scripts/<verb>.rb. JS is only the distribution + dispatch mechanism.
+//
+//   npx @zalom/plastic install   [flags]
+//   npx @zalom/plastic update    [flags]
+//   npx @zalom/plastic uninstall [flags]
+//   npx @zalom/plastic versions  [flags]
+//
+// Back-compat: a bare `--uninstall` (no subcommand) routes to uninstall with a deprecation
+// warning; no subcommand at all defaults to install (legacy behaviour, one release).
+
+import { execFileSync } from 'node:child_process'
+import { resolve } from 'node:path'
+import { existsSync } from 'node:fs'
+
+const VERBS = ['install', 'update', 'uninstall', 'versions']
+const packageRoot = new URL('..', import.meta.url).pathname
+const argv = process.argv.slice(2)
+
+let verb
+let rest
+
+if (VERBS.includes(argv[0])) {
+  verb = argv[0]
+  rest = argv.slice(1)
+} else if (argv.includes('--uninstall')) {
+  // Deprecated: `--uninstall` as a flag instead of the `uninstall` subcommand.
+  console.error('! plastic: `--uninstall` is deprecated — use `npx @zalom/plastic uninstall`. (works for now)')
+  verb = 'uninstall'
+  rest = argv.filter((a) => a !== '--uninstall')
+} else {
+  // No subcommand: legacy default to install (one release of grace).
+  verb = 'install'
+  rest = argv
+}
+
+const script = resolve(packageRoot, 'scripts', `${verb}.rb`)
+
+if (!existsSync(script)) {
+  console.error(`Error: scripts/${verb}.rb not found in package.`)
+  process.exit(1)
+}
+
+try {
+  execFileSync('ruby', [script, ...rest], {
+    stdio: 'inherit',
+    env: { ...process.env, PLASTIC_PACKAGE_ROOT: packageRoot },
+  })
+} catch (err) {
+  if (err.status) process.exit(err.status)
+  console.error('Error: Ruby is required to run Plastic.')
+  console.error('  macOS: Ruby is pre-installed')
+  console.error('  Linux: sudo apt install ruby / dnf install ruby')
+  process.exit(1)
+}

package/bin/test

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Runs the FULL Minitest suite in a single process.
+#
+# `release.verify` used to be `ruby -Itest test/*_test.rb`, but Ruby runs only
+# the first glob-expanded file as the program — the rest land in ARGV and are
+# never required. The release gate exercised one test file, reported green, and
+# let releases ship over real failures (intent 30). Pointing verify at this
+# script keeps the runner in version control and guarantees every test file is
+# loaded.
+
+root = File.expand_path("..", __dir__)
+
+files = Dir.glob(File.join(root, "test", "**", "*_test.rb")).sort
+abort "No test files found under #{File.join(root, "test")}" if files.empty?
+
+# `bin/test --list` prints the discovered files without running them, so the
+# discovery logic can be tested cheaply (no full-suite execution).
+if ARGV.delete("--list")
+  puts files.map { |f| f.sub("#{root}/", "") }
+  exit 0
+end
+
+$LOAD_PATH.unshift File.join(root, "test")
+require "minitest/autorun"
+files.each { |f| require f }

package/deprecations.yml

@@ -11,13 +11,4 @@
 #   removal: semver where feature is removed
 #   link: optional URL to migration guide
 
-deprecations:
-  - id: cc-plugin-to-npx
-    severity: info
-    summary: "Plastic distribution is moving from Claude Code plugin to npx install"
-    migration_steps:
-      - "Install new distribution: npx @zalom/plastic@latest"
-      - "Verify: check that ~/.plastic/ is intact and hooks work"
-      - "Remove old plugin: /plugin remove plastic"
-    introduced: "1.0.0"
-    removal: "2.0.0"
+deprecations: []

package/hooks/auto-arm

@@ -0,0 +1,5 @@
+#!/bin/bash
+INPUT=$(cat)
+MESSAGE=$(echo "$INPUT" | ruby -rjson -e 'puts JSON.parse(STDIN.read)["user_prompt"].to_s' 2>/dev/null || echo "")
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+ruby "$SCRIPT_DIR/../scripts/hook-auto-arm" "$MESSAGE"

package/hooks/bash-gate

@@ -0,0 +1,3 @@
+#!/bin/bash
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+exec ruby "$SCRIPT_DIR/../scripts/hook-bash-gate"

package/hooks/check-update

@@ -1,11 +1,15 @@
 #!/bin/bash
-# plastic-hook-version: 1.0.0
-# Runs on SessionStart — checks npm for newer version, writes cache
+# plastic-hook-version: 1.1.0
+# Runs on SessionStart — checks npm for a newer version on the installed
+# channel, writes cache. Channel-aware: queries dist-tags and picks the best
+# upgrade target instead of blindly trusting the `latest` tag.
 
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 PLASTIC_HOME="$HOME/.plastic"
 CACHE_DIR="$PLASTIC_HOME/.cache"
 CACHE_FILE="$CACHE_DIR/update-check.json"
 VERSION_FILE="$PLASTIC_HOME/VERSION"
+SELECTOR="$SCRIPT_DIR/../scripts/select-update-target"
 
 mkdir -p "$CACHE_DIR"
 
@@ -21,21 +25,21 @@ fi
 
 # Background check — don't block session start
 (
-  RAW=$(npm view @zalom/plastic version 2>/dev/null)
-  LATEST=$(echo "$RAW" | grep -oE '^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.]+)?$')
+  TAGS=$(npm view @zalom/plastic dist-tags --json 2>/dev/null)
 
-  if [ -z "$LATEST" ]; then
+  if [ -z "$TAGS" ]; then
     exit 0
   fi
 
+  TARGET=$(printf '%s' "$TAGS" | ruby "$SELECTOR" "$CURRENT" 2>/dev/null)
   CHECKED=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 
-  if [ "$LATEST" != "$CURRENT" ]; then
+  if [ -n "$TARGET" ]; then
     printf '{"current":"%s","latest":"%s","checked":"%s","updateAvailable":true}\n' \
-      "$CURRENT" "$LATEST" "$CHECKED" > "$CACHE_FILE"
+      "$CURRENT" "$TARGET" "$CHECKED" > "$CACHE_FILE"
   else
     printf '{"current":"%s","latest":"%s","checked":"%s","updateAvailable":false}\n' \
-      "$CURRENT" "$LATEST" "$CHECKED" > "$CACHE_FILE"
+      "$CURRENT" "$CURRENT" "$CHECKED" > "$CACHE_FILE"
   fi
 ) &
 

package/hooks/code-gate

@@ -0,0 +1,12 @@
+#!/bin/bash
+INPUT=$(cat)
+FILE_PATH=$(echo "$INPUT" | ruby -rjson -e 'data = JSON.parse(STDIN.read); puts data.dig("tool_params", "file_path") || data.dig("tool_input", "file_path") || ""' 2>/dev/null)
+
+if [ -z "$FILE_PATH" ]; then
+  exit 0
+fi
+
+SESSION_ID=$(echo "$INPUT" | ruby -rjson -e 'data = JSON.parse(STDIN.read); puts data.dig("session_id") || ""' 2>/dev/null)
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+ruby "$SCRIPT_DIR/../scripts/hook-code-gate" "$FILE_PATH" "$SESSION_ID"

package/hooks/create-gate

@@ -0,0 +1,3 @@
+#!/bin/bash
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+exec ruby "$SCRIPT_DIR/../scripts/hook-create-gate"

package/hooks/gate-check

@@ -6,5 +6,7 @@ if [ -z "$FILE_PATH" ]; then
   exit 0
 fi
 
+SESSION_ID=$(echo "$INPUT" | ruby -rjson -e 'data = JSON.parse(STDIN.read); puts data.dig("session_id") || ""' 2>/dev/null)
+
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-ruby "$SCRIPT_DIR/../scripts/hook-gate-check" "$FILE_PATH"
+ruby "$SCRIPT_DIR/../scripts/hook-gate-check" "$FILE_PATH" "$SESSION_ID"

package/hooks/hooks.json

@@ -29,6 +29,38 @@
         ]
       }
     ],
+    "PreToolUse": [
+      {
+        "matcher": "Write|Edit|NotebookEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" code-gate",
+            "statusMessage": "Checking lifecycle gate..."
+          }
+        ]
+      },
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" create-gate",
+            "statusMessage": "Checking create gate..."
+          }
+        ]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" bash-gate",
+            "statusMessage": "Checking lifecycle gate..."
+          }
+        ]
+      }
+    ],
     "PostToolUse": [
       {
         "matcher": "Write|Edit",
@@ -61,6 +93,26 @@
             "statusMessage": "Checking future intents..."
           }
         ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/auto-arm\"",
+            "statusMessage": "Checking auto mode..."
+          }
+        ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" qmd-search",
+            "statusMessage": "Searching QMD..."
+          }
+        ]
       }
     ]
   }