@zalom/plastic 1.14.1 → 2.0.0-alpha.10

package/agents/plastic-spec-specialist.md

@@ -1,53 +0,0 @@
----
-name: plastic-spec-specialist
-description: |
-  Use at the Why-to-How boundary in auto mode: consolidate the enriched Why into
-  spec.md from the spec template.
-model: sonnet
----
-
-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 all 8 sections in template order: Problem, Goals,
-   Non-Goals, Approach, Alternatives Considered, Decisions, Acceptance Criteria, Open Questions.
-   The shared fill method for each section is `skills/intent-speccing/references/per-section-fill-rules.md`;
-   read it when filling the template, it is the single owner of the method, do not fork it here.
-3. **Stamp the tier**: write a `Tier: S|M|L` line as the TOP line of spec.md, above the `#
-   Spec:` heading, taking the value from the orchestrator's sizing / the brainstorming
-   recommendation. This line is convention-only: read by the orchestrator, never validated by
-   any gate or by doctor. It is an extra top line, not a template field, so no template changes.
-4. **Accept collapsed sections at S/M**: a spec.md whose Problem, Goals, Non-Goals, Approach,
-   Decisions, or Acceptance Criteria sections are a single line each is still a complete
-   spec.md under the same-structure invariant; do not pad it. The gates check file existence
-   and realness, not artifact depth, so a collapsed-but-real spec passes.
-5. **Make it the contract**: the spec is what the planner and executor build against
-6. **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 (see `## Completion Report`); the enforcer checks the spec against its exit criteria before How begins
-
-## Completion Report
-
-END your turn with a structured completion report as your final message, per the spawn preamble's `REPORT_CONTRACT` and `skills/auto/references/agent-report-contract.md`. Do not finish silently. Carry the common envelope (role, intent id, stage, status, artifacts written, verification, checklist deltas, deviations, blockers, insights) plus the spec payload:
-
-- The spec sections produced (Problem, Goals, Non-Goals, Approach, Decisions, Acceptance Criteria)
-- How the recorded decisions resolved into the chosen approach
-- The acceptance-criteria count, so the planner knows the surface to cover
-- The stamped `Tier:` value
-
-## 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/hooks/auto-arm

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

package/hooks/bash-gate

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

package/hooks/continue

@@ -1,31 +0,0 @@
-#!/bin/bash
-INPUT=$(cat)
-MESSAGE=$(echo "$INPUT" | env -u RUBYOPT ruby -rjson -e 'puts JSON.parse(STDIN.read)["user_prompt"]' 2>/dev/null || echo "")
-
-if echo "$MESSAGE" | grep -iq '\bcontinue\b'; then
-  GLOBAL_INDEX="$HOME/.plastic/INDEX.md"
-
-  if [ ! -f "$GLOBAL_INDEX" ]; then
-    exit 0
-  fi
-
-  INDEX="$GLOBAL_INDEX"
-  STORE_ROOT="$HOME/.plastic"
-  MODE="global"
-
-  SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-  OUTPUT=$(env -u RUBYOPT ruby "$SCRIPT_DIR/../scripts/hook-continue" "$INDEX" "$STORE_ROOT" "$MODE" 2>/dev/null)
-
-  if [ -n "$OUTPUT" ]; then
-    echo "$OUTPUT"
-  else
-    cat <<'HOOKJSON'
-{
-  "hookSpecificOutput": {
-    "hookEventName": "UserPromptSubmit",
-    "additionalContext": "PLASTIC CONTINUE: The user wants to resume previous work.\n\nRead ~/.plastic/INDEX.md and follow the plastic-continuing skill workflow."
-  }
-}
-HOOKJSON
-  fi
-fi

package/hooks/edit-gates

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

package/hooks/future-intent-check

@@ -1,25 +0,0 @@
-#!/bin/bash
-INPUT=$(cat)
-MESSAGE=$(echo "$INPUT" | env -u RUBYOPT ruby -rjson -e 'puts JSON.parse(STDIN.read)["user_prompt"].downcase' 2>/dev/null || echo "")
-
-if [ ${#MESSAGE} -lt 10 ]; then
-  exit 0
-fi
-
-if echo "$MESSAGE" | grep -qx '\s*continue\s*'; then
-  exit 0
-fi
-
-GLOBAL_INDEX="$HOME/.plastic/INDEX.md"
-LOCAL_INDEX=".plastic/INDEX.md"
-
-if [ -f "$GLOBAL_INDEX" ]; then
-  STORE_ROOT="$HOME/.plastic"
-elif [ -f "$LOCAL_INDEX" ]; then
-  STORE_ROOT=".plastic"
-else
-  exit 0
-fi
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-env -u RUBYOPT ruby "$SCRIPT_DIR/../scripts/hook-future-intent-check" "$STORE_ROOT" "$MESSAGE"

package/hooks/gate-check

@@ -1,12 +0,0 @@
-#!/bin/bash
-INPUT=$(cat)
-FILE_PATH=$(echo "$INPUT" | env -u RUBYOPT 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" | env -u RUBYOPT ruby -rjson -e 'data = JSON.parse(STDIN.read); puts data.dig("session_id") || ""' 2>/dev/null)
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-env -u RUBYOPT ruby "$SCRIPT_DIR/../scripts/hook-gate-check" "$FILE_PATH" "$SESSION_ID"

package/hooks/power-tools

@@ -1,8 +0,0 @@
-#!/bin/bash
-# power-tools mandate hook launcher (intents 66, 66b, 187, 246). No-op when there is no global store.
-GLOBAL_INDEX="$HOME/.plastic/INDEX.md"
-if [ ! -f "$GLOBAL_INDEX" ]; then
-  exit 0
-fi
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-exec env -u RUBYOPT ruby "$SCRIPT_DIR/../scripts/hook-power-tools"

package/scripts/hook-auto-arm

@@ -1,51 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-# frozen_string_literal: true
-
-# Usage: hook-auto-arm <message>
-# UserPromptSubmit arming (intent 27). Two jobs, both additive context — never blocks:
-#   1. Detect auto-trigger phrases -> steer the agent to invoke plastic-auto.
-#   2. If auto mode is armed and the active intent hasn't reached How -> remind the agent
-#      that project-code edits are gate-blocked until plan.md + checklist.md exist.
-# Outputs UserPromptSubmit hookSpecificOutput JSON, or exits silently.
-
-require "json"
-require_relative "lib/bridge"
-
-message = (ARGV[0] || "").downcase
-parts = []
-
-# --- 1. Auto-trigger steering ---
-AUTO_TRIGGERS = ["take it from here", "deliver this", "/plastic-auto", "auto mode"].freeze
-# bare "auto" only as a standalone word to avoid matching "automatic", "automation", etc.
-triggered = AUTO_TRIGGERS.any? { |p| message.include?(p) } || message.match?(/\bauto\b/)
-if triggered
-  parts << "Auto-mode request detected. Invoke the plastic-auto skill to deliver the " \
-           "active intent autonomously — it arms the lifecycle gate so project code " \
-           "cannot be edited before plan.md + checklist.md exist."
-end
-
-# --- 2. Standing gate reminder when armed and pre-How ---
-bridge_data = Bridge.discover_bridge(session: ENV["CLAUDE_CODE_SESSION_ID"], cwd: Dir.pwd)
-if bridge_data && bridge_data.dig("build", "auto") == true
-  intent = bridge_data["intent"] || {}
-  store = intent["store"]; dir = intent["dir"]
-  if store && dir
-    intent_dir = File.expand_path("#{store}/#{dir}")
-    reached_how = File.exist?("#{intent_dir}/plan.md") && File.exist?("#{intent_dir}/checklist.md")
-    unless reached_how
-      parts << "Auto mode armed on intent #{intent["id"]} — produce spec -> plan -> " \
-               "checklist before editing project code. Code edits are gate-blocked until then."
-    end
-  end
-end
-
-exit 0 if parts.empty?
-
-payload = {
-  "hookSpecificOutput" => {
-    "hookEventName" => "UserPromptSubmit",
-    "additionalContext" => parts.join("\n")
-  }
-}
-puts JSON.generate(payload)

package/scripts/hook-bash-gate

@@ -1,78 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-# frozen_string_literal: true
-
-# PreToolUse gate for Bash (intent 27a): close the Bash-edit bypass. When auto
-# mode is armed and the active intent has not reached How (plan.md + checklist.md),
-# block Bash commands that WRITE project code outside the store.
-#
-# Reads the Claude Code PreToolUse payload as JSON on STDIN:
-#   { "tool_input": { "command": "..." }, "cwd": "..." }
-# Empty / unparseable / no command => exit 0 (allow). Conservatism is the prime
-# directive: when a command's write intent is ambiguous, ALLOW.
-#
-# Exit 0 = allow. Exit 2 = block (reason on stderr, shown to the agent).
-
-require "json"
-require_relative "lib/bridge"
-
-raw = $stdin.read rescue nil
-exit 0 if raw.nil? || raw.strip.empty?
-
-payload = JSON.parse(raw) rescue nil
-exit 0 unless payload.is_a?(Hash)
-
-command = payload.dig("tool_input", "command") || payload.dig("tool_params", "command")
-exit 0 if command.nil? || command.to_s.strip.empty?
-
-cwd = payload["cwd"]
-cwd = Dir.pwd if cwd.nil? || cwd.to_s.empty?
-
-session = payload["session_id"]
-session = ENV["CLAUDE_CODE_SESSION_ID"] if session.nil? || session.to_s.empty?
-
-# Auditable escape (intent 108, D7): a trailing `# plastic-ok` allows the
-# command and logs it, so sanctioned writes are visible, not silent.
-if Bridge.bash_escape?(command)
-  begin
-    require "fileutils"
-    log = File.join(Dir.home, ".plastic", ".cache", "gate-escapes.log")
-    FileUtils.mkdir_p(File.dirname(log))
-    File.open(log, "a") do |io|
-      io.puts("#{Time.now.utc.iso8601}\t#{session}\t#{command.gsub(/\s+/, ' ').strip}")
-    end
-  rescue StandardError
-    # the escape still applies; logging is best-effort
-  end
-  exit 0
-end
-
-# --- Load bridge (shared resolution; stdin session_id -> CLAUDE_CODE_SESSION_ID -> /tmp scan) ---
-# A nil bridge does NOT short-circuit (intent 108): the lock gate decides from
-# the durable delivery.lock file, so it must run even without a bridge cache.
-bridge_data = Bridge.discover_bridge(session: session, cwd: cwd)
-
-reason = Bridge.bash_gate_decision(bridge_data, command, cwd: cwd, session: session)
-exit 0 unless reason
-
-# Block log (intent 229): one six-field TSV line, hand-rolled here exactly as
-# the escape write above is, so this script keeps requiring only lib/bridge and
-# pays no extra load on every Bash tool call. Best-effort: the block applies
-# regardless.
-begin
-  require "fileutils"
-  require "time"
-  blocklog = File.join(Dir.home, ".plastic", ".cache", "gate-blocks.log")
-  FileUtils.mkdir_p(File.dirname(blocklog))
-  intent_id = bridge_data.is_a?(Hash) ? bridge_data.dig("intent", "id").to_s : ""
-  File.open(blocklog, "a") do |io|
-    io.puts([Time.now.utc.iso8601, "bash-gate", session.to_s, intent_id,
-             command.to_s.gsub(/\s+/, " ").strip,
-             reason.to_s.gsub(/\s+/, " ").strip].join("\t"))
-  end
-rescue StandardError
-  # the block still applies; logging is best-effort
-end
-
-$stderr.puts "PLASTIC GATE — #{reason}"
-exit 2

package/scripts/hook-code-gate

@@ -1,38 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-# frozen_string_literal: true
-
-# Usage: hook-code-gate <file_path> [session_id] [content]
-# PreToolUse gate. Composes two independent block rules; EITHER blocks the edit:
-#   - Stage rule (intent 27): when auto mode is armed and the active intent has not
-#     reached How (plan.md + checklist.md), block edits to project code outside the store.
-#   - Worktree isolation rule (intent 73c2): when the intent has a provisioned code
-#     worktree, block project-code edits outside it; and block edits to another
-#     intent's store dir whose delivery lock is held by a live non-owner session.
-#
-# Exit 0 = allow. Exit 2 = block (reason on stderr, shown to the agent).
-# No bridge = allow. Each rule fails open on its own conditions (see bridge.rb).
-#
-# Thin CLI wrapper (intent 244): the gate logic itself lives in
-# scripts/lib/edit_gates.rb, shared with the merged Claude dispatcher
-# (scripts/hook-edit-gates) and, since intent 251, the merged Codex dispatcher
-# (scripts/lib/codex_edit_gates.rb). This wrapper has no production caller on
-# either harness anymore; it remains as the per-gate isolation surface for the
-# hook test suite.
-
-require_relative "lib/edit_gates"
-
-file_path = ARGV[0]
-exit 0 unless file_path && !file_path.empty?
-
-session = (ARGV[1] unless ARGV[1].to_s.empty?) || ENV["CLAUDE_CODE_SESSION_ID"]
-
-ctx = EditGates::Context.new(
-  tool_name: "Write", session: session, gate_path: file_path, file_path: file_path,
-  content: ARGV[2], harness: "claude",
-)
-
-outcome = EditGates.code_gate(ctx)
-exit 0 unless outcome
-outcome.lines.each { |line| $stderr.puts line }
-exit 2

package/scripts/hook-continue

@@ -1,48 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-# Usage: hook-continue <index_path> <store_root> <mode>
-# Renders the dashboard `continue` cockpit as UserPromptSubmit additionalContext.
-# Exits silently (no output) if the dashboard produces nothing — the bash caller
-# then falls back to a minimal notice.
-
-require "json"
-require "open3"
-require_relative "lib/dashboard_banner"
-
-index_path, _store_root, _mode = ARGV
-exit 0 unless index_path && File.exist?(index_path)
-
-dashboard = File.expand_path("dashboard.rb", __dir__)
-exit 0 unless File.exist?(dashboard)
-
-cockpit, _err, status = Open3.capture3({"RUBYOPT" => nil}, "ruby", dashboard, "continue")
-exit 0 unless status.success? && !cockpit.strip.empty?
-
-context = cockpit.rstrip +
-  "\n\nFollow the plastic-continuing skill workflow to resume: " \
-  "if active intents exist, read their state and resume; otherwise surface the " \
-  "most-valuable next work and any stale or triage intents from the board above."
-
-payload = {
-  "hookSpecificOutput" => {
-    "hookEventName" => "UserPromptSubmit",
-    "additionalContext" => context
-  }
-}
-
-# Hook-owned systemMessage floor (intent 125, Task 6): a hard fallback summary
-# independent of the agent's reply, mirroring hook-session-start's BootBanner
-# pattern. Best-effort only — any failure here (subprocess, JSON, renderer)
-# degrades silently, omitting systemMessage; this hook must never crash
-# UserPromptSubmit over a summary line.
-begin
-  data_json, _data_err, data_status = Open3.capture3({"RUBYOPT" => nil}, "ruby", dashboard, "continue", "--data")
-  if data_status.success?
-    banner = DashboardBanner.render(JSON.parse(data_json))
-    payload["systemMessage"] = banner if banner
-  end
-rescue StandardError
-  nil
-end
-
-puts JSON.generate(payload)

package/scripts/hook-create-gate

@@ -1,51 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-# frozen_string_literal: true
-
-# PreToolUse create gate (intent 60b): validate the PROPOSED content of a Write
-# to an intent file before it lands. Fires when the target path is an intent file
-# inside its own equally-named directory (store/<id>--<slug>/<id>--<slug>.md). It
-# validates the proposed content from the hook payload (tool_input.content), NOT
-# the on-disk file (which does not exist yet at PreToolUse), using IntentValidator
-# for born-complete frontmatter plus the sanctioned section structure.
-#
-# It depends ONLY on the stdin path + content, never on the auto-bridge or any
-# session id, so it runs unconditionally (headless / background sessions).
-# It validates ONLY the intent file, never sentinel placeholder lifecycle files
-# (spec.md/plan.md/etc.); the path matcher excludes them.
-#
-# Exit 0 = allow. Exit 2 = block (reason on stderr, shown to the agent).
-#
-# Reads the Claude Code PreToolUse payload as JSON on STDIN:
-#   { "tool_input": { "file_path": "...", "content": "..." } }
-# Empty / unparseable / non-matching path => exit 0 (cannot judge, allow).
-# Three payload shapes on a matching path (intent 108, D7):
-#   Write (content):        validate the proposed content.
-#   Edit (old_string):      simulate the replacement on the on-disk file and
-#                           validate the RESULT; a missing file blocks.
-#   Pathless MCP mutation:  validate the CURRENT on-disk file (the PostToolUse
-#                           gate-check backstop validates the result); a
-#                           missing file blocks (fail-safe).
-#
-# Thin CLI wrapper (intent 244): the gate logic itself lives in
-# scripts/lib/edit_gates.rb, shared with the merged Claude dispatcher
-# (scripts/hook-edit-gates) and, since intent 251, the merged Codex dispatcher
-# (scripts/lib/codex_edit_gates.rb). This wrapper has no production caller on
-# either harness anymore; it remains as the per-gate isolation surface for the
-# hook test suite. Deliberately WITHOUT a top-level rescue, matching this
-# script's behavior before the extraction: an internal exception here has
-# never been caught.
-
-require "json"
-require_relative "lib/edit_gates"
-
-raw = $stdin.read rescue nil
-exit 0 if raw.nil? || raw.strip.empty?
-
-payload = JSON.parse(raw) rescue nil
-exit 0 unless payload.is_a?(Hash)
-
-outcome = EditGates.create_gate(EditGates.context_from(payload))
-exit 0 unless outcome
-outcome.lines.each { |line| $stderr.puts line }
-exit 2

package/scripts/hook-edit-gates

@@ -1,58 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-# frozen_string_literal: true
-
-# The merged Claude PreToolUse edit-path dispatcher (intent 244). One registered
-# hook, one Ruby process, one stdin parse, five gates in-process, in the fixed
-# order savepoint-pre, lock-gate, code-gate, links-gate, create-gate (spec D-a).
-# The first deny ends evaluation and its own shape is reproduced exactly: stderr
-# plus exit 2 for code-gate/links-gate/create-gate, stdout permissionDecision
-# JSON plus exit 0 for lock-gate (spec D-b). savepoint-pre runs first so its
-# `started` ledger append stays unconditional, including on a call another gate
-# then blocks (spec D-c).
-#
-# Fail-open everywhere (spec D-i): each gate runs inside its own rescue in
-# EditGates.dispatch, and this file's top level rescues to exit 0, so a gate bug
-# never denies and never silences a sibling gate.
-#
-# LOAD-BEARING SHAPE: doctor's claude_hooks_implemented_check reads THIS FILE as
-# plain text and extracts the `when "<gate>"` labels of the `case gate` statement
-# below, because a script with top-level side effects can never be required to
-# introspect it (the same technique intent 200 used for scripts/codex-hook). If
-# the case statement is reshaped, update that check in scripts/doctor.rb in the
-# same change, or it will fail loudly by design.
-
-require "json"
-require_relative "lib/edit_gates"
-
-def route(gate, ctx)
-  case gate
-  when "savepoint-pre" then EditGates.savepoint_pre(ctx)
-  when "lock-gate"     then EditGates.lock_gate(ctx)
-  when "code-gate"     then EditGates.code_gate(ctx)
-  when "links-gate"    then EditGates.links_gate(ctx)
-  when "create-gate"   then EditGates.create_gate(ctx)
-  end
-end
-
-begin
-  raw = begin
-    $stdin.read
-  rescue StandardError
-    nil
-  end
-  exit 0 if raw.nil? || raw.strip.empty?
-
-  payload = begin
-    JSON.parse(raw)
-  rescue StandardError
-    nil
-  end
-  exit 0 unless payload.is_a?(Hash)
-
-  exit EditGates.dispatch(ctx: EditGates.context_from(payload), route: method(:route))
-rescue StandardError => e
-  # Dispatcher-internal failure: never impersonate a deny (spec D-i).
-  $stderr.puts "plastic edit-gates error: #{e.message}"
-  exit 0
-end

package/scripts/hook-future-intent-check

@@ -1,90 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-# Usage: hook-future-intent-check <store_root> <message>
-# Outputs hook JSON when the user's message matches future intent keywords.
-# Exits silently if no matches.
-
-require "json"
-require "yaml"
-
-store_root, message = ARGV
-exit 0 unless store_root && message
-
-index_path = "#{store_root}/INDEX.md"
-exit 0 unless File.exist?(index_path)
-
-# --- Find future intent dirs ---
-
-lines = File.readlines(index_path)
-future_dirs = []
-section = nil
-
-lines.each do |line|
-  section = :future if line.start_with?("## Future")
-  section = nil if line.start_with?("## ") && !line.start_with?("## Future")
-  next unless section == :future && line.strip.start_with?("- [")
-
-  if line =~ /store\/([\w-]+)\//
-    future_dirs << $1
-  end
-end
-
-exit 0 if future_dirs.empty?
-
-# --- Match keywords against message ---
-
-matches = []
-message_words = message.split(/\W+/).reject { |w| w.length < 4 }
-
-future_dirs.each do |dir|
-  intent_path = "#{store_root}/store/#{dir}/#{dir}.md"
-  next unless File.exist?(intent_path)
-
-  content = File.read(intent_path)
-
-  tags = []
-  if content =~ /^tags:\s*\[([^\]]+)\]/
-    tags = $1.split(",").map(&:strip).map(&:downcase)
-  end
-
-  intent_name = ""
-  if content =~ /^intent:\s*["']?(.+?)["']?\s*$/
-    intent_name = $1.downcase
-  end
-
-  intent_id = ""
-  if content =~ /^id:\s*["']?([a-z0-9]+)["']?\s*$/
-    intent_id = $1
-  end
-
-  keywords = tags + intent_name.split(/\W+/).reject { |w| w.length < 4 }
-  keywords = keywords.map(&:downcase).uniq
-
-  matched_keywords = keywords.select { |kw| message.include?(kw) }
-  name_matches = message_words.select { |w| intent_name.include?(w) }
-  matched_keywords = (matched_keywords + name_matches).uniq
-
-  if matched_keywords.length >= 1
-    index_line = lines.find { |l| l.include?(dir) }&.strip || "#{intent_id} — #{intent_name}"
-    matches << { "index_line" => index_line, "keywords" => matched_keywords }
-  end
-end
-
-exit 0 if matches.empty?
-
-# --- Build context ---
-
-parts = []
-parts << "PLASTIC — Future intents related to this message:\n"
-matches.each do |m|
-  parts << "#{m["index_line"]} (matched: #{m["keywords"].join(", ")})"
-end
-parts << "\nConsider asking the user if they want to activate any of these, or note the connection."
-
-payload = {
-  "hookSpecificOutput" => {
-    "hookEventName" => "UserPromptSubmit",
-    "additionalContext" => parts.join("\n")
-  }
-}
-puts JSON.generate(payload)