@zalom/plastic 1.0.0-alpha.35 → 1.0.0-alpha.37

package/hooks/hooks.json

@@ -93,6 +93,16 @@
             "statusMessage": "Checking auto mode..."
           }
         ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" qmd-search",
+            "statusMessage": "Searching QMD..."
+          }
+        ]
       }
     ]
   }

package/hooks/qmd-search

@@ -0,0 +1,8 @@
+#!/bin/bash
+# qmd-first search hook launcher (intent 66). 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 ruby "$SCRIPT_DIR/../scripts/hook-qmd-search" "$HOME/.plastic"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalom/plastic",
-  "version": "1.0.0-alpha.35",
+  "version": "1.0.0-alpha.37",
   "description": "Intent-driven idea development system for AI coding agents",
   "type": "module",
   "bin": {

package/scripts/doctor.rb

@@ -42,6 +42,7 @@ class Doctor
     plastic-gate-check
     plastic-continue
     plastic-future-intent-check
+    plastic-qmd-search
   ].freeze
 
   CLAUDE_HOOK_EVENTS = %w[SessionStart PreCompact PostToolUse UserPromptSubmit].freeze

package/scripts/hook-qmd-search

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# qmd-first UserPromptSubmit hook (intent 66). Reads the prompt from stdin JSON,
+# delegates the decision to QmdHook.run under a hard timeout, and prints
+# hookSpecificOutput when there is something to inject/remind. Silent no-op (exit
+# 0) when qmd is absent, the prompt is trivial, or anything goes wrong. ARGV[0]
+# is the plastic_home (passed by the launcher); defaults to ~/.plastic.
+require "json"
+require "timeout"
+require_relative "lib/qmd_hook"
+
+raw = begin
+  STDIN.read
+rescue StandardError
+  ""
+end
+
+prompt = begin
+  parsed = JSON.parse(raw)
+  parsed.is_a?(Hash) ? parsed["user_prompt"].to_s : ""
+rescue StandardError
+  ""
+end
+
+plastic_home = (ARGV[0] && !ARGV[0].empty?) ? ARGV[0] : File.expand_path("~/.plastic")
+
+context = begin
+  Timeout.timeout(2) do
+    QmdHook.run(prompt: prompt, cwd: Dir.pwd, plastic_home: plastic_home)
+  end
+rescue Exception
+  nil
+end
+
+exit 0 if context.nil? || context.strip.empty?
+
+puts JSON.generate(
+  "hookSpecificOutput" => {
+    "hookEventName" => "UserPromptSubmit",
+    "additionalContext" => context,
+  }
+)

package/scripts/lib/bridge.rb

@@ -10,6 +10,14 @@ require "digest"
 module Bridge
   STAGES = %w[what why how exec done].freeze
 
+  # Stale-bridge purge window (intent 67). The bridge file is ephemeral
+  # live-session gate state, NOT a continuation source: an intent is resumed from
+  # its savepoint.md ledger, never from a /tmp bridge. So any bridge older than
+  # this window is dead weight and safe to purge, regardless of arm state. No
+  # real session stays live for two days, so a 48h cutoff never removes a bridge
+  # an active run depends on.
+  PURGE_AGE_SECONDS = 48 * 3600   # 48 hours
+
   def self.intent_file(intent_dir)
     dir_name = File.basename(intent_dir)
     "#{intent_dir}/#{dir_name}.md"
@@ -106,6 +114,40 @@ module Bridge
     pool.max_by { |c| c[:mtime] }&.fetch(:data)
   end
 
+  # --- Stale-bridge purge (intent 67) ---------------------------------------
+  #
+  # Remove stale tmp/plastic-*.json bridge files so discover_bridge's per-fire
+  # scan stays bounded. Best-effort and non-raising: returns the array of removed
+  # paths. Continuation does not depend on these files (an intent resumes from its
+  # savepoint.md ledger), so the only safety rule is age: a bridge older than
+  # max_age_seconds is purged regardless of arm state, while anything newer is kept
+  # (it may be a live run). The current session's own bridge is never purged
+  # (preserves the disarm_auto contract that it stays readable). Wired into
+  # arm_auto and disarm_auto so both manual and auto delivery keep the temp dir
+  # clean.
+  def self.purge_stale_bridges(session:, now: Time.now, max_age_seconds: PURGE_AGE_SECONDS,
+                               tmp: tmp_dir)
+    current = path(session, tmp: tmp)
+    removed = []
+    Dir.glob(File.join(tmp, "plastic-*.json")).each do |f|
+      next if f == current
+      begin
+        next if (now - File.mtime(f)) < max_age_seconds
+        File.delete(f)
+        removed << f
+      rescue Errno::ENOENT
+        # Raced with another job that already removed it; count as purged.
+        removed << f
+      rescue => e
+        $stderr.puts "plastic: purge skipped #{f}: #{e.message}"
+      end
+    end
+    removed
+  rescue => e
+    $stderr.puts "plastic: purge_stale_bridges failed: #{e.message}"
+    removed || []
+  end
+
   def self.read(session, tmp: tmp_dir)
     p = path(session, tmp: tmp)
     return nil unless File.exist?(p)
@@ -323,6 +365,7 @@ module Bridge
     data = derive(key, intent_id: intent_id, intent_dir: intent_dir, store: store, name: name)
     data["build"]["auto"] = true
     write(key, data)
+    purge_stale_bridges(session: key)
     data
   end
 
@@ -333,6 +376,7 @@ module Bridge
     data["build"] ||= {}
     data["build"]["auto"] = false
     write(session, data)
+    purge_stale_bridges(session: session)
     data
   end
 

package/scripts/lib/installer_core.rb

@@ -199,6 +199,8 @@ class InstallerCore
       "scripts/hook-continue" => "scripts/hook-continue",
       "scripts/hook-future-intent-check" => "scripts/hook-future-intent-check",
       "scripts/hook-gate-check" => "scripts/hook-gate-check",
+      "scripts/hook-qmd-search" => "scripts/hook-qmd-search",
+      "scripts/lib/qmd_hook.rb" => "scripts/lib/qmd_hook.rb",
       "scripts/hook-code-gate" => "scripts/hook-code-gate",
       "scripts/hook-bash-gate" => "scripts/hook-bash-gate",
       "scripts/hook-auto-arm" => "scripts/hook-auto-arm",
@@ -543,6 +545,7 @@ class InstallerCore
           { "type" => "command", "command" => "#{hook_dir}/plastic-continue", "statusMessage" => "Checking for continue..." },
           { "type" => "command", "command" => "#{hook_dir}/plastic-future-intent-check", "statusMessage" => "Checking future intents..." },
           { "type" => "command", "command" => "#{hook_dir}/plastic-auto-arm", "statusMessage" => "Checking auto mode..." },
+          { "type" => "command", "command" => "#{hook_dir}/plastic-qmd-search", "statusMessage" => "Searching QMD..." },
         ],
       },
     }

package/scripts/lib/qmd_hook.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require_relative "qmd_sync"
+
+# QmdHook — decision logic for the qmd-first UserPromptSubmit hook (intent 66).
+# Pure and dependency-injected: returns the additionalContext string to emit, or
+# nil to emit nothing. The executable hook wires real deps and prints; this is
+# unit-tested with a fake runner/detector (no real qmd, no network).
+module QmdHook
+  module_function
+
+  MIN_PROMPT_LENGTH = 10
+  REMINDER = "qmd is available: query it (`qmd search` / `qmd query` over the " \
+             "`plastic-*` collections) before grep/Read when gathering intent " \
+             "context (sources/chain) or checking whether this work already " \
+             "exists as an intent."
+
+  def run(prompt:, cwd:, plastic_home:, runner: QmdSync.default_runner,
+          detector: QmdSync.method(:detect), limit: 3, min_score: 0.5)
+    return nil unless detector.call
+    p = prompt.to_s.strip
+    return nil if p.length < MIN_PROMPT_LENGTH
+    return nil if p.downcase == "continue"
+
+    collections = QmdSync.collections_for_cwd(cwd, plastic_home: plastic_home)
+    hits = QmdSync.search(p, collections: collections, limit: limit,
+                          min_score: min_score, runner: runner, detector: detector)
+
+    parts = []
+    if hits.any?
+      parts << "Related / prior Plastic intents (qmd BM25, includes completed) — " \
+               "check before treating this as new work:"
+      hits.each do |h|
+        loc = h[:file].to_s.sub(%r{\Aqmd://}, "")
+        pct = (h[:score] * 100).round
+        parts << "- [#{pct}%] #{loc} — #{h[:title]}"
+      end
+      parts << ""
+    end
+    parts << REMINDER
+    parts.join("\n")
+  end
+end

package/scripts/lib/qmd_sync.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "yaml"
+require "json"
 
 # QmdSync — the single place Plastic talks to QMD (intent 45a).
 #
@@ -111,6 +112,55 @@ module QmdSync
       missing: missing, all_registered: missing.empty? }
   end
 
+  # Read-only BM25 search over one or more collections. Returns hits sorted by
+  # score (desc), filtered by min_score, capped at limit:
+  #   [{ score: Float, file: String, line: Integer|nil, title: String, snippet: String }, ...]
+  # No-ops to [] when qmd is absent or the query is blank. Uses `qmd search --json`
+  # (BM25, no embeddings / no model downloads). Pure via the injected runner.
+  def search(query, collections:, limit: 3, min_score: 0.5, runner: default_runner, detector: method(:detect))
+    return [] unless detector.call
+    q = query.to_s.strip
+    return [] if q.empty? || Array(collections).empty?
+
+    args = ["search", q]
+    Array(collections).each { |c| args.concat(["-c", c]) }
+    args << "--json"
+
+    out, ok = runner.call(args)
+    return [] unless ok && out && !out.strip.empty?
+
+    parsed = begin
+      JSON.parse(out)
+    rescue StandardError
+      return []
+    end
+    return [] unless parsed.is_a?(Array)
+
+    parsed.filter_map do |h|
+      next unless h.is_a?(Hash)
+      score = h["score"].to_f
+      next if score < min_score
+      { score: score, file: h["file"].to_s, line: h["line"],
+        title: h["title"].to_s, snippet: h["snippet"].to_s }
+    end.sort_by { |h| -h[:score] }.first(limit)
+  end
+
+  # Which collections to search for a given working directory: the matched
+  # project's collection plus plastic-global, or just plastic-global when the
+  # CWD is not inside any registered project. Project match = CWD equals the
+  # registered path or is nested under it.
+  def collections_for_cwd(cwd, plastic_home:)
+    cwd = File.expand_path(cwd)
+    projects = load_projects(plastic_home)
+    slug, = projects.find do |_s, info|
+      path = info.is_a?(Hash) ? info["path"] : nil
+      next false unless path
+      root = File.expand_path(path)
+      cwd == root || cwd.start_with?(root + File::SEPARATOR)
+    end
+    slug ? ["plastic-#{slug}", "plastic-global"] : ["plastic-global"]
+  end
+
   # --- internals ---
 
   def skip_result

package/skills/auto/SKILL.md

@@ -194,6 +194,8 @@ During initial project creation, all decisions are non-destructive by definition
    ```bash
    ruby -r ~/.plastic/scripts/lib/bridge -e 'Bridge.disarm_auto(ENV["CLAUDE_SESSION_ID"])'
    ```
+   Disarming also purges stale bridge files from the temp directory automatically (it keeps the
+   current bridge and any live run), so no manual `/tmp` cleanup is needed.
 10. Notify user: "Intent [ID] — [name] delivered. [1-2 sentence summary]. See outcome.md for details."
 
 ## Error Handling