@zalom/plastic 1.3.0 → 1.4.1

package/scripts/lib/lock.rb

@@ -24,7 +24,30 @@ require "time"
 module Lock
   module_function
 
+  # Skill-invocation prefix per harness (intent 201, D2/D3). Claude Code invokes a
+  # skill with a slash (/plastic-doctor); Codex CLI invokes explicitly with a
+  # dollar ($plastic-doctor) and may also select one implicitly by matching the
+  # skill's description. This table is the actual source of truth for
+  # Bridge.skill_ref (bridge.rb requires lock.rb, never the reverse, so the
+  # table lives here rather than pulling Bridge into this dependency-free file
+  # just to render two characters). InstallerCore::DEFAULT_AGENTS carries the
+  # same values per adapter as documented config (see ACTION_2); this constant
+  # is not read from it at runtime, by the same reasoning bridge.rb/hook-*
+  # already stay clear of installer_core.rb (spec Alternatives Considered).
+  SKILL_PREFIXES = { "claude" => "/", "codex" => "$" }.freeze
+
+  # Renders a skill reference for the given harness. Unset or unrecognized
+  # harness falls back to Claude's slash form, so an existing call site that
+  # never passes harness: keeps behaving exactly as it does today (D2). name
+  # is the bare skill name ("plastic-doctor"), never pre-prefixed.
+  def self.skill_ref(name, harness: :claude)
+    prefix = SKILL_PREFIXES.fetch(harness.to_s, SKILL_PREFIXES["claude"])
+    "#{prefix}#{name}"
+  end
+
   TYPES = %w[delivery maintenance].freeze
+  DELEGATE_ACTIVITY_LIMIT = 20
+  DELEGATE_STATUSES = %w[active finished failed].freeze
 
   # Lease TTL. Heartbeats fire from the write-path hooks (PostToolUse
   # gate-check and the lock-gate allow path), so a delivering session
@@ -84,7 +107,8 @@ module Lock
   #   [:excluded, other] the OTHER lock type is fresh (D3)
   #   [:corrupt, nil]    unparseable lock file: run repair
   def acquire(intent_dir, session:, type: "delivery", host: Socket.gethostname,
-              ttl: TTL_SECONDS, now: Time.now)
+              ttl: TTL_SECONDS, now: Time.now, harness: nil, agent: nil,
+              model: nil, thread: nil, run_mode: nil)
     raise ArgumentError, "unknown lock type #{type.inspect}" unless TYPES.include?(type)
     raise ArgumentError, "lock session must be present" if blank?(session)
 
@@ -99,7 +123,13 @@ module Lock
     if existing
       if existing["owner_session"].to_s == session.to_s
         data = payload(session: session, type: type, host: host, now: now,
-                       delegates: Array(existing["delegates"]))
+                       delegates: Array(existing["delegates"]),
+                       delegate_activity: Array(existing["delegate_activity"]),
+                       harness: merged_value(harness, existing["owner_harness"]),
+                       agent: merged_value(agent, existing["owner_agent"]),
+                       model: merged_value(model, existing["owner_model"]),
+                       thread: merged_value(thread, existing["owner_thread"]),
+                       run_mode: merged_value(run_mode, existing["run_mode"]))
         write(intent_dir, data, type: type)
         return [:owned, data]
       end
@@ -107,7 +137,9 @@ module Lock
       return [:stale, existing]
     end
 
-    data = payload(session: session, type: type, host: host, now: now)
+    data = payload(session: session, type: type, host: host, now: now,
+                   harness: harness, agent: agent, model: model, thread: thread,
+                   run_mode: run_mode)
     File.open(path(intent_dir, type: type),
               File::WRONLY | File::CREAT | File::EXCL) do |io|
       io.write(JSON.pretty_generate(data))
@@ -117,16 +149,49 @@ module Lock
     [:held, read(intent_dir, type: type)] # lost the O_EXCL race
   end
 
-  def payload(session:, type:, host:, now:, delegates: [])
+  def payload(session:, type:, host:, now:, delegates: [], delegate_activity: [],
+              harness: nil, agent: nil, model: nil, thread: nil, run_mode: nil)
     {
       "type" => type,
       "owner_session" => session.to_s,
       "host" => host,
       "acquired_at" => now.utc.iso8601,
       "delegates" => delegates,
+      "owner_harness" => normalized_value(harness),
+      "owner_agent" => normalized_value(agent),
+      "owner_model" => normalized_value(model),
+      "owner_thread" => normalized_value(thread),
+      "run_mode" => normalized_value(run_mode),
+      "delegate_activity" => bounded_delegate_activity(delegate_activity, delegates: delegates),
     }
   end
 
+  def normalized_value(value)
+    blank?(value) ? nil : value.to_s
+  end
+
+  def merged_value(explicit, existing)
+    blank?(explicit) ? normalized_value(existing) : explicit.to_s
+  end
+
+  # Keep every active record that still names an authorized delegate, while
+  # bounding completed history. Active work is current truth and must never be
+  # evicted merely because newer delegates finished.
+  def bounded_delegate_activity(records, delegates:)
+    records = Array(records)
+    authorized = Array(delegates).map(&:to_s)
+    terminal_indexes = records.each_index.reject do |index|
+      record = records[index]
+      record.is_a?(Hash) && record["status"].to_s == "active" &&
+        authorized.include?(record["session"].to_s)
+    end.last(DELEGATE_ACTIVITY_LIMIT)
+    records.each_with_index.filter_map do |record, index|
+      active = record.is_a?(Hash) && record["status"].to_s == "active" &&
+               authorized.include?(record["session"].to_s)
+      record if active || terminal_indexes.include?(index)
+    end
+  end
+
   # Owner/delegate heartbeat: touch the mtime, never rewrite content.
   def heartbeat(intent_dir, session:, type: "delivery", now: Time.now)
     return false unless holds?(intent_dir, session: session, type: type)
@@ -136,11 +201,49 @@ module Lock
 
   # Owner registers a delegate (D4): a session allowed to write under this
   # lock. Only the OWNER may delegate; delegates cannot re-delegate.
-  def add_delegate(intent_dir, delegate:, session:, type: "delivery")
+  def add_delegate(intent_dir, delegate:, session:, type: "delivery", now: Time.now,
+                   harness: nil, agent: nil, model: nil, thread: nil)
     data = read(intent_dir, type: type)
     return false if blank?(delegate)
     return false unless data && data["owner_session"].to_s == session.to_s
     data["delegates"] = (Array(data["delegates"]) + [delegate.to_s]).uniq
+    activity = Array(data["delegate_activity"])
+    previous = activity.find { |record| record.is_a?(Hash) && record["session"].to_s == delegate.to_s }
+    activity.reject! { |record| record.is_a?(Hash) && record["session"].to_s == delegate.to_s }
+    record = {
+      "session" => delegate.to_s,
+      "status" => "active",
+      "registered_at" => now.utc.iso8601,
+      "last_activity_at" => now.utc.iso8601,
+      "harness" => merged_value(harness, previous && previous["harness"]),
+      "agent" => merged_value(agent, previous && previous["agent"]),
+      "model" => merged_value(model, previous && previous["model"]),
+      "thread" => merged_value(thread, previous && previous["thread"]),
+    }
+    data["delegate_activity"] = bounded_delegate_activity(activity + [record],
+                                                          delegates: data["delegates"])
+    write(intent_dir, data, type: type)
+    true
+  end
+
+  # Activity metadata is observational only. Finishing or failing a delegate
+  # never removes its string session id from the authorization list.
+  def update_delegate_status(intent_dir, delegate:, status:, session:, type: "delivery",
+                             now: Time.now)
+    return false unless (DELEGATE_STATUSES - ["active"]).include?(status.to_s)
+    data = read(intent_dir, type: type)
+    return false unless data && data["owner_session"].to_s == session.to_s
+    activity = Array(data["delegate_activity"])
+    index = activity.index do |record|
+      record.is_a?(Hash) && record["session"].to_s == delegate.to_s
+    end
+    return false unless index
+    activity[index] = activity[index].merge(
+      "status" => status.to_s,
+      "last_activity_at" => now.utc.iso8601
+    )
+    data["delegate_activity"] = bounded_delegate_activity(activity,
+                                                          delegates: data["delegates"])
     write(intent_dir, data, type: type)
     true
   end
@@ -164,7 +267,8 @@ module Lock
   # lock; there is no silent reclaim path anywhere else.
   # Returns [:taken, data], [:fresh, existing], or acquire's error statuses.
   def takeover(intent_dir, session:, type: "delivery", host: Socket.gethostname,
-               ttl: TTL_SECONDS, now: Time.now)
+               ttl: TTL_SECONDS, now: Time.now, harness: nil, agent: nil,
+               model: nil, thread: nil, run_mode: nil)
     existing = read(intent_dir, type: type)
     if existing && !authorized?(existing, session) &&
        fresh?(intent_dir, type: type, ttl: ttl, now: now)
@@ -175,7 +279,8 @@ module Lock
     p = path(intent_dir, type: type)
     File.delete(p) if File.exist?(p)
     status, data = acquire(intent_dir, session: session, type: type, host: host,
-                           ttl: ttl, now: now)
+                           ttl: ttl, now: now, harness: harness, agent: agent,
+                           model: model, thread: thread, run_mode: run_mode)
     return [status, data] unless status == :acquired
 
     audit = "#{now.utc.iso8601}  Lock  takeover: #{session} reclaimed #{type} " \
@@ -190,6 +295,75 @@ module Lock
   def write(intent_dir, data, type: "delivery")
     File.write(path(intent_dir, type: type), JSON.pretty_generate(data))
   end
+
+  # Read-only normalized inspection. The lock file and its mtime remain the
+  # sole sources of owner and heartbeat truth; no environment or transcript
+  # inference belongs here.
+  def who(intent_dir, ttl: TTL_SECONDS, now: Time.now)
+    p = path(intent_dir)
+    unless File.exist?(p)
+      return { "state" => "none",
+               "claims" => Claim.claims_status(intent_dir, ttl: ttl, now: now) }
+    end
+    data = read(intent_dir)
+    unless data
+      return { "state" => "corrupt",
+               "claims" => Claim.claims_status(intent_dir, ttl: ttl, now: now) }
+    end
+
+    activity = Array(data["delegate_activity"])
+    activity_by_session = activity.each_with_object({}) do |record, memo|
+      memo[record["session"].to_s] = record if record.is_a?(Hash)
+    end
+    authorized_sessions = Array(data["delegates"]).map(&:to_s)
+    activity_sessions = activity.filter_map do |record|
+      record["session"].to_s if record.is_a?(Hash) &&
+                                authorized_sessions.include?(record["session"].to_s)
+    end.uniq
+    activity_order = activity.each_with_index.each_with_object({}) do |(record, index), memo|
+      memo[record["session"].to_s] = index if record.is_a?(Hash)
+    end
+    activity_sessions.sort_by! do |session|
+      record = activity_by_session[session] || {}
+      # Active delegates are current ahead of terminal delegates. Within that
+      # group, latest activity wins; original record order is the stable
+      # fallback for legacy records without timestamps.
+      [record["status"].to_s == "active" ? 1 : 0,
+       record["last_activity_at"].to_s, activity_order.fetch(session, -1)]
+    end
+    # Legacy string-only delegates retain their authorization order. Rich
+    # records follow in deterministic current/latest order, so consumers may
+    # reliably take the last projection entry: the most recent active delegate
+    # when one exists, otherwise the most recent terminal activity.
+    ordered_sessions = (authorized_sessions - activity_sessions) + activity_sessions
+    delegates = ordered_sessions.map do |session|
+      record = activity_by_session[session] || {}
+      {
+        "session" => session,
+        "harness" => normalized_value(record["harness"]) || "unknown",
+        "agent" => normalized_value(record["agent"]) || "unknown",
+        "model" => normalized_value(record["model"]) || "unknown",
+        "thread" => normalized_value(record["thread"]) || "unknown",
+        "status" => normalized_value(record["status"]) || "unknown",
+        "registered_at" => record["registered_at"],
+        "last_activity_at" => record["last_activity_at"],
+      }
+    end
+    {
+      "state" => fresh?(intent_dir, ttl: ttl, now: now) ? "fresh" : "stale",
+      "owner" => {
+        "harness" => normalized_value(data["owner_harness"]) || "unknown",
+        "agent" => normalized_value(data["owner_agent"]) || "unknown",
+        "model" => normalized_value(data["owner_model"]) || "unknown",
+        "thread" => normalized_value(data["owner_thread"]) || "unknown",
+        "run_mode" => normalized_value(data["run_mode"]) || "unknown",
+      },
+      "owner_session" => data["owner_session"],
+      "heartbeat_at" => File.mtime(p).utc.iso8601,
+      "delegates" => delegates,
+      "claims" => Claim.claims_status(intent_dir, ttl: ttl, now: now),
+    }
+  end
 end
 
 # Claim: the per-artifact claim-token layer (intent 111, D1/D7). Sits BENEATH
@@ -359,7 +533,8 @@ module Claim
   # ENGAGES only when a claim file exists (dormant otherwise, so single-owner flows
   # and the existing suite stay green, AC7). Fails open on stale/corrupt via
   # fail_open?, the named contract.
-  def claim_gate_reason(intent_dir, artifact, session:, ttl: Lock::TTL_SECONDS, now: Time.now)
+  def claim_gate_reason(intent_dir, artifact, session:, ttl: Lock::TTL_SECONDS, now: Time.now,
+                        harness: :claude)
     return nil if Lock.blank?(artifact)
     return nil unless File.exist?(path(intent_dir, artifact))   # dormant: no claim
     return nil if holds_claim?(intent_dir, artifact, session: session)  # you hold it
@@ -368,8 +543,8 @@ module Claim
     holder = data && data["owner_session"]
     since = data && data["acquired_at"]
     "artifact #{artifact} is claimed by #{holder} since #{since}; another writer holds " \
-      "it. Back off or run /plastic-doctor check the lock status. If you are a distinct " \
-      "delegate, the owner must register you: plastic-lock delegate --intent-dir " \
-      "#{intent_dir} --session <your-session-id>"
+      "it. Back off or run #{Lock.skill_ref('plastic-doctor', harness: harness)} check the " \
+      "lock status. If you are a distinct delegate, the owner must register you: " \
+      "plastic-lock delegate --intent-dir #{intent_dir} --session <your-session-id>"
   end
 end

package/scripts/lib/power_tools.rb

@@ -3,17 +3,18 @@
 
 require_relative "qmd_sync"
 
-# PowerTools — detect-then-degrade harness for Plastic's optional power-tools
-# (intent 66b; demoted to recommendations in intent 108, D8). It owns
-# deterministic detection of each tool and builds a RECOMMENDATION string for
-# whichever tools are present, so the agent is reminded (not obliged) to prefer
-# them: QMD for finding intents, Serena for code navigation.
+# PowerTools - detect-then-degrade harness for Plastic's optional power-tools
+# (intent 66b; demoted to recommendations in intent 108, D8; Enola added in
+# intent 187). It owns deterministic detection of each tool and builds a
+# RECOMMENDATION string for whichever tools are present, so the agent is
+# reminded (not obliged) to prefer them: QMD for finding intents, Enola or
+# Serena for code navigation.
 #
 # Strictly detect-then-degrade: a tool that is absent contributes nothing, and
 # `mandate` returns nil when no tool is present. Nothing here installs anything.
 #
 # Pure and dependency-injected: every detection runs through an injected callable
-# or keyword probe (PATH scan / `.serena` marker walk), so the whole module is
+# or keyword probe (PATH scan / marker-directory walk), so the whole module is
 # unit-testable with no real binaries, no network, and no global/ENV state.
 module PowerTools
   module_function
@@ -31,6 +32,15 @@ module PowerTools
     !!path_probe.call
   end
 
+  # True when Enola is present: a `.enola` directory exists in cwd or any
+  # ancestor (a generated snapshot), OR `enola` is resolvable on PATH. Both
+  # probes are injectable so tests do not depend on the host having Enola
+  # installed or indexed (intent 187).
+  def enola?(cwd:, path_probe: method(:which_enola), marker_finder: method(:enola_marker?))
+    return true if marker_finder.call(cwd)
+    !!path_probe.call
+  end
+
   # True when `serena` is an executable on PATH. Mirrors QmdSync.which_qmd.
   def which_serena
     ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? do |dir|
@@ -39,6 +49,14 @@ module PowerTools
     end
   end
 
+  # True when `enola` is an executable on PATH. Mirrors which_serena.
+  def which_enola
+    ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? do |dir|
+      candidate = File.join(dir, "enola")
+      File.file?(candidate) && File.executable?(candidate)
+    end
+  end
+
   # Walk up from cwd to the filesystem root, returning true if any level holds a
   # `.serena` directory.
   def serena_marker?(cwd)
@@ -52,26 +70,51 @@ module PowerTools
     false
   end
 
+  # Walk up from cwd to the filesystem root, returning true if any level holds
+  # an `.enola` directory (a generated snapshot).
+  def enola_marker?(cwd)
+    dir = File.expand_path(cwd)
+    loop do
+      return true if Dir.exist?(File.join(dir, ".enola"))
+      parent = File.dirname(dir)
+      break if parent == dir
+      dir = parent
+    end
+    false
+  end
+
   QMD_OBLIGATION = "prefer `qmd search` / `qmd query` over the `plastic-*` " \
                    "collections to check for existing or related intents before " \
                    "treating work as new"
   SERENA_OBLIGATION = "prefer its symbolic tools (find_symbol / get_symbols_overview / " \
                        "find_referencing_symbols) for code navigation"
+  ENOLA_OBLIGATION = "prefer its MCP symbol resolution (or `.enola/facts.jsonl`) for " \
+                     "code navigation over grep"
 
   # Recommendation text for whichever tools are present, or nil when none are.
-  # Both present collapse to ONE combined line naming both obligations (no
-  # embedded newline); one present returns that tool's own line; neither
-  # returns nil.
-  def mandate(cwd:, qmd_detector: QmdSync.method(:detect), serena_detector: nil)
+  # QMD plus a code-navigation tool collapse to ONE combined line naming both
+  # obligations (no embedded newline); one tool present returns that tool's own
+  # line; neither returns nil.
+  #
+  # Enola-first: Enola and Serena share ONE code-navigation slot. When both are
+  # present, only Enola is named (intent 187, matching the owner's standing
+  # Enola-first ruling and avoiding a bloated three-tool line). The QMD-only and
+  # Serena-only lines are unchanged from before Enola existed.
+  def mandate(cwd:, qmd_detector: QmdSync.method(:detect), serena_detector: nil, enola_detector: nil)
     qmd_present = qmd?(detector: qmd_detector)
+    enola_present = enola_detector ? !!enola_detector.call : enola?(cwd: cwd)
     serena_present = serena_detector ? !!serena_detector.call : serena?(cwd: cwd)
 
-    if qmd_present && serena_present
-      "QMD and Serena are available: #{QMD_OBLIGATION}, and #{SERENA_OBLIGATION}."
+    nav_present = enola_present || serena_present
+    nav_name = enola_present ? "Enola" : "Serena"
+    nav_obligation = enola_present ? ENOLA_OBLIGATION : SERENA_OBLIGATION
+
+    if qmd_present && nav_present
+      "QMD and #{nav_name} are available: #{QMD_OBLIGATION}, and #{nav_obligation}."
     elsif qmd_present
       "QMD is available: #{QMD_OBLIGATION}."
-    elsif serena_present
-      "Serena is available: #{SERENA_OBLIGATION}."
+    elsif nav_present
+      "#{nav_name} is available: #{nav_obligation}."
     end
   end
 end

package/scripts/lib/project_validator.rb

@@ -0,0 +1,113 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "yaml"
+
+# ProjectValidator - the single source of truth for "is a project spawn
+# complete?" (intent 190).
+#
+# A project can be registered in projects.yml, have a store, and still be
+# missing the pieces a real project needs: project.yml, a root AGENTS.md.
+# The intent-26 spawn shipped exactly that shape and was caught only by a
+# much later, pull-only plastic-doctor sweep. This module lets
+# plastic-project-creating verify a spawn BEFORE announcing it as done,
+# mirroring how scripts/new-intent already runs IntentValidator before
+# announcing a new intent (validate-intent).
+#
+# Pure and dependency-injected: validate accepts an injectable plastic_home,
+# uses no eval, performs no file writes, no global-constant injection.
+# scripts/doctor.rb's check_project_store already covers 4 of these 6
+# invariants (project_dir_exists, project_store_dir, project_index,
+# project_yml_exists) plus cross_references, advisorially and pull-only;
+# doctor adopting this module is a named follow-up, not part of this intent
+# (D8). Invariant 4 (project-root AGENTS.md) has no existing check anywhere.
+module ProjectValidator
+  module_function
+
+  def validate(slug, plastic_home: File.join(Dir.home, ".plastic"))
+    missing = []
+    errors = []
+
+    entry = registration_for(slug, plastic_home)
+    unless entry
+      missing << "projects.yml registration"
+      errors << "project '#{slug}' is not registered in projects.yml with a 'path' key"
+      return { ok: false, missing: missing, errors: errors }
+    end
+
+    project_path = entry["path"].to_s
+
+    # Invariant 2: registered project directory exists on disk.
+    unless File.directory?(project_path)
+      missing << "project directory"
+      errors << "registered project directory does not exist: #{project_path}"
+    end
+
+    project_dir = File.join(plastic_home, "projects", slug)
+
+    # Invariant 3: project.yml exists AND parses as YAML.
+    project_yml_path = File.join(project_dir, "project.yml")
+    if File.exist?(project_yml_path)
+      parsed = begin
+        YAML.safe_load(File.read(project_yml_path))
+      rescue StandardError
+        nil
+      end
+      unless parsed.is_a?(Hash)
+        missing << "project.yml (valid YAML)"
+        errors << "project.yml exists at #{project_yml_path} but does not parse as YAML"
+      end
+    else
+      missing << "project.yml"
+      errors << "project.yml missing at #{project_yml_path}"
+    end
+
+    # Invariant 4: project-root AGENTS.md (the registered path, NOT
+    # ~/.plastic/projects/{slug}/). This is the intent-26 spawn's gap,
+    # uncaught by doctor.rb today.
+    agents_md_path = File.join(project_path, "AGENTS.md")
+    unless File.exist?(agents_md_path)
+      missing << "AGENTS.md (project root)"
+      errors << "AGENTS.md missing at project root: #{agents_md_path}"
+    end
+
+    # Invariant 5: store/ exists.
+    store_dir = File.join(project_dir, "store")
+    unless File.directory?(store_dir)
+      missing << "store/"
+      errors << "store directory missing: #{store_dir}"
+    end
+
+    # Invariant 6: INDEX.md exists.
+    index_md_path = File.join(project_dir, "INDEX.md")
+    unless File.exist?(index_md_path)
+      missing << "INDEX.md"
+      errors << "INDEX.md missing: #{index_md_path}"
+    end
+
+    { ok: missing.empty?, missing: missing, errors: errors }
+  end
+
+  # Invariant 1: registered in projects.yml with a 'path'. Returns the
+  # project's entry Hash, or nil when unregistered or the entry has no path.
+  def registration_for(slug, plastic_home)
+    projects = load_projects(plastic_home)
+    entry = projects[slug]
+    entry.is_a?(Hash) && entry["path"] ? entry : nil
+  end
+
+  # Parse projects.yml -> the `projects` Hash, or {} on any error/absence.
+  # Mirrors StoreProvisioning.load_projects.
+  def load_projects(plastic_home)
+    path = File.join(plastic_home, "projects.yml")
+    return {} unless File.exist?(path)
+
+    data = begin
+      YAML.safe_load(File.read(path)) || {}
+    rescue StandardError
+      {}
+    end
+    projects = data.is_a?(Hash) ? data["projects"] : nil
+    projects.is_a?(Hash) ? projects : {}
+  end
+end

package/scripts/lib/qmd_hook.rb

@@ -4,14 +4,15 @@
 require_relative "qmd_sync"
 require_relative "power_tools"
 
-# QmdHook — decision logic for the power-tools UserPromptSubmit hook (intents 66,
+# QmdHook - decision logic for the power-tools UserPromptSubmit hook (intents 66,
 # 66b). 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).
 #
 # When qmd is present it still injects scored qmd hits (intent 66), then appends
-# the PowerTools mandate (a MUST obligation per present tool: qmd for finding
-# intents, serena for code navigation) instead of the old soft reminder.
+# the PowerTools mandate (a recommendation per present tool: qmd for finding
+# intents, Enola-first for code navigation, falling back to Serena; intent 187
+# added the enola_detector alongside the pre-existing serena_detector).
 module QmdHook
   module_function
 
@@ -19,11 +20,13 @@ module QmdHook
 
   def run(prompt:, cwd:, plastic_home:, runner: QmdSync.default_runner,
           detector: QmdSync.method(:detect), limit: 3, min_score: 0.5,
-          serena_detector: nil)
+          serena_detector: nil, enola_detector: nil)
     serena_detector ||= -> { PowerTools.serena?(cwd: cwd) }
+    enola_detector ||= -> { PowerTools.enola?(cwd: cwd) }
     qmd_present = !!detector.call
     serena_present = !!serena_detector.call
-    return nil unless qmd_present || serena_present
+    enola_present = !!enola_detector.call
+    return nil unless qmd_present || serena_present || enola_present
 
     p = prompt.to_s.strip
     # The hit SEARCH is the only expensive step and the only one gated by prompt
@@ -37,19 +40,20 @@ module QmdHook
       hits = QmdSync.search(p, collections: collections, limit: limit,
                             min_score: min_score, runner: runner, detector: detector)
       if hits.any?
-        parts << "Related / prior Plastic intents (qmd BM25, includes completed) — " \
+        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]}"
+          parts << "- [#{pct}%] #{loc} - #{h[:title]}"
         end
         parts << ""
       end
     end
 
     mandate = PowerTools.mandate(cwd: cwd, qmd_detector: -> { qmd_present },
-                                 serena_detector: -> { serena_present })
+                                 serena_detector: -> { serena_present },
+                                 enola_detector: -> { enola_present })
     parts << mandate if mandate
     return nil if parts.empty?
     parts.join("\n")