@zalom/plastic 1.0.0-beta.8 → 1.0.0

package/scripts/link-suggest

@@ -0,0 +1,213 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# link-suggest - support links decided by CONTEXT INFLUENCE (intent 91, D7). Links are
+# NOT graded by a script: whether one intent's context influenced another is a
+# judgement an agent makes by reading the candidate's Intent + Context. This tool
+# gathers candidates with that evidence, records a CONFIRMED edge in frontmatter plus a
+# dated rating/reason line in the intent's `## Insights` section, and flags drift. It
+# never writes a `## Links` line and never deletes.
+#
+# `## Links` is a DERIVED view of `sources`/`chain` (Convention over Configuration).
+# Tiers, by context influence:
+#   sources - the foundational context that shaped this intent's creation.
+#   chain   - the context that materially helps DELIVER this intent. HIGH bar.
+#   tags    - loose theme grouping for search. Not a link.
+#
+# Usage:
+#   link-suggest <subject_id> [--store-dir PATH] [--plastic-home PATH]
+#   link-suggest <subject_id> --record <target_id> --edge <sources|chain>
+#                --rating <high|medium|low> --reason "..." --confirm
+#   link-suggest --help
+#
+# Default (no --record) prints candidates WITH their Intent+Context plus any drift, and
+# writes nothing. --record without --confirm prints what would happen and writes
+# nothing. --edge is explicit and required (sources is decided by origin, never
+# inferred); --rating is required when --edge is chain.
+
+require_relative "lib/link_suggestions"
+
+module LinkSuggestCLI
+  module_function
+
+  DEFAULT_HOME = File.join(Dir.home, ".plastic")
+
+  USAGE = <<~TXT
+    Usage:
+      link-suggest <subject_id> [--store-dir PATH] [--plastic-home PATH]
+      link-suggest <subject_id> --record <target_id> --edge <sources|chain> \\
+                   --rating <high|medium|low> --reason "..." --confirm
+      link-suggest --help
+
+    Links are decided by context influence, judged by an agent reading each
+    candidate's Intent + Context. This tool only gathers candidates with that
+    evidence, records a confirmed edge plus its rating/reason in the intent's
+    ## Insights section, and flags drift. It never writes a ## Links line and
+    never deletes.
+
+    --edge is explicit and required (sources is decided by origin, never inferred).
+    --rating is required when --edge is chain. Without --confirm, nothing is written.
+  TXT
+
+  def parse(argv)
+    opts = { home: DEFAULT_HOME, store_dir: nil, subject: nil, help: false,
+             record: nil, edge: nil, rating: nil, reason: nil, confirm: false }
+    i = 0
+    while i < argv.length
+      case argv[i]
+      when "--help", "-h" then opts[:help] = true; i += 1
+      when "--plastic-home" then opts[:home] = argv[i + 1]; i += 2
+      when "--store-dir" then opts[:store_dir] = argv[i + 1]; i += 2
+      when "--record" then opts[:record] = argv[i + 1]; i += 2
+      when "--edge" then opts[:edge] = (argv[i + 1] || "").to_sym; i += 2
+      when "--rating" then opts[:rating] = argv[i + 1]; i += 2
+      when "--reason" then opts[:reason] = argv[i + 1]; i += 2
+      when "--confirm" then opts[:confirm] = true; i += 1
+      else
+        opts[:subject] ||= argv[i]
+        i += 1
+      end
+    end
+    opts[:store_dir] ||= File.join(opts[:home], "store")
+    opts
+  end
+
+  # Print the discovery candidates with their Intent + Context evidence, plus drift.
+  def report(tool, subject, out: $stdout)
+    nodes = tool.load_nodes
+    unless nodes.key?(subject)
+      out.puts "link-suggest: no intent #{subject.inspect} in #{tool.store_dir}"
+      return 1
+    end
+
+    cands = tool.gather(subject, nodes: nodes)
+    out.puts "Candidates for #{subject} (discovery only; judge influence by reading context):"
+    if cands.empty?
+      out.puts "  (none)"
+    else
+      cands.each { |c| print_candidate(c, out) }
+    end
+
+    flaws = tool.drift(subject, nodes: nodes)
+    out.puts "Drift for #{subject}:"
+    if flaws.empty?
+      out.puts "  (none)"
+    else
+      flaws.each { |f| out.puts "  [drift] #{f.detail}" }
+    end
+    0
+  end
+
+  def print_candidate(cand, out)
+    out.puts "  - #{cand.id}  #{cand.label}"
+    out.puts "    Intent:  #{excerpt(cand.intent)}" unless cand.intent.empty?
+    out.puts "    Context: #{excerpt(cand.context)}" unless cand.context.empty?
+  end
+
+  # A one-paragraph excerpt of a section, for scannable evidence.
+  def excerpt(text, limit: 280)
+    flat = text.to_s.gsub(/\s+/, " ").strip
+    flat.length > limit ? "#{flat[0, limit]}..." : flat
+  end
+
+  def do_record(tool, opts, out: $stdout)
+    if opts[:edge].nil? || !%i[sources chain].include?(opts[:edge])
+      out.puts "link-suggest: --record requires --edge sources|chain (explicit, never inferred)."
+      return 1
+    end
+    if opts[:edge] == :chain && (opts[:rating].nil? || !LinkSuggestions::RATINGS.include?(opts[:rating]))
+      out.puts "link-suggest: --rating high|medium|low is required for a chain edge."
+      return 1
+    end
+
+    unless opts[:confirm]
+      out.puts "Would record #{opts[:edge]} edge #{opts[:subject]} -> #{opts[:record]} " \
+               "(rating #{opts[:rating] || "-"}, reason: #{opts[:reason] || "-"}). " \
+               "Re-run with --confirm to write. Nothing written."
+      return 0
+    end
+
+    wrote = tool.record_edge(opts[:subject], opts[:record],
+                             edge: opts[:edge], rating: opts[:rating],
+                             reason: opts[:reason], confirm: true)
+    if wrote
+      out.puts "Recorded #{opts[:edge]} edge #{opts[:subject]} -> #{opts[:record]} " \
+               "and appended a rating/reason line to the intent's ## Insights. " \
+               "Reproject ## Links with scripts/project-links."
+      return 0
+    end
+    out.puts "No edge written (edge may already exist, or intent missing)."
+    0
+  end
+
+  def run(argv, out: $stdout)
+    opts = parse(argv)
+    if opts[:help]
+      out.puts USAGE
+      return 0
+    end
+    unless opts[:subject]
+      out.puts USAGE
+      return 1
+    end
+
+    tool = LinkSuggestions.new(store_dir: opts[:store_dir], finder: build_finder(opts[:store_dir]))
+
+    return do_record(tool, opts, out: out) if opts[:record]
+
+    report(tool, opts[:subject], out: out)
+  end
+
+  # The real candidate-finder, wired here (not in the lib): use QMD when available,
+  # else fall back to the lib's cheap family/tag/adjacent net. Discovery only.
+  def build_finder(store_dir)
+    qmd = qmd_finder(store_dir)
+    qmd || LinkSuggestions::FamilyTagFinder.new
+  end
+
+  # A QMD-backed finder when the `qmd` (or qmd-sync) CLI is on PATH. It seeds discovery
+  # from the subject's intent line, unions the hits with the cheap fallback net, and
+  # returns ids present in the store. Any failure falls back silently. Discovery only,
+  # never a grade.
+  def qmd_finder(_store_dir)
+    return nil unless qmd_available?
+
+    fallback = LinkSuggestions::FamilyTagFinder.new
+    lambda do |subject_id, nodes|
+      base = fallback.call(subject_id, nodes)
+      subject = nodes[subject_id]
+      return base unless subject
+
+      hits = qmd_search_ids(subject[:label], nodes)
+      (base + hits).uniq.reject { |id| id == subject_id }
+    end
+  end
+
+  def qmd_available?
+    %w[qmd qmd-sync].any? { |c| system("command -v #{c} >/dev/null 2>&1") }
+  rescue StandardError
+    false
+  end
+
+  # Best-effort: ask qmd-sync for related text and map any id-shaped tokens back to
+  # store ids. Never raises; returns [] on any trouble.
+  def qmd_search_ids(query, nodes)
+    return [] if query.to_s.strip.empty?
+
+    out = `ruby #{File.join(Dir.home, ".plastic", "scripts", "qmd-sync")} search #{shell_quote(query)} 2>/dev/null`
+    return [] if out.nil? || out.empty?
+
+    out.scan(/\b([0-9]+[a-z0-9]*)\b/).flatten.uniq.select { |id| nodes.key?(id) }
+  rescue StandardError
+    []
+  end
+
+  def shell_quote(str)
+    "'#{str.to_s.gsub("'", "'\\\\''")}'"
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  exit LinkSuggestCLI.run(ARGV)
+end

package/scripts/new-intent

@@ -26,6 +26,9 @@ require "fileutils"
 require "date"
 require_relative "lib/bridge"
 require_relative "lib/intent_validator"
+require_relative "lib/graph_rebuild"
+require_relative "lib/links_projection"
+require_relative "lib/links_section"
 
 # --- Explicit flag parsing (no eval, no global injection) ------------------
 
@@ -106,25 +109,119 @@ def add_to_chain(file_path, new_id)
   File.write(file_path, ["", new_fm, parts[2]].join("---"))
 end
 
-# Append a wikilink line under the file's `## Links` section, idempotently.
-def append_link(file_path, link_line)
-  return unless File.exist?(file_path)
-  content = File.read(file_path)
-  return if content.include?(link_line)
+# Derive [plastic_home, referer_store_key] from a store directory path so the
+# cross-store resolver (shared with project-links and the doctor check) can be
+# built. A global store is `<home>/store` (key "global"); a project store is
+# `<home>/projects/<slug>/store` (key "project:<slug>"). Returns
+# [nil, "global"] only if the layout is unrecognized, in which case Links
+# projection falls back to single-store resolution rooted at this store.
+def store_context(store)
+  store = File.expand_path(store)
+  parent = File.dirname(store)               # `<home>` or `<home>/projects/<slug>`
+  if File.basename(store) == "store" && File.basename(File.dirname(parent)) == "projects"
+    slug = File.basename(parent)
+    home = File.dirname(File.dirname(parent)) # strip projects/<slug>
+    [home, "project:#{slug}"]
+  elsif File.basename(store) == "store"
+    [parent, "global"]                        # `<home>/store`
+  else
+    [parent, "global"]
+  end
+end
+
+# The in-scope stores under `plastic_home`, each { key:, store: }. Mirrors
+# project-links/RebuildGraph#stores so cross-store resolution spans the family.
+def family_stores(plastic_home)
+  list = []
+  global_store = File.join(plastic_home, "store")
+  list << { key: "global", store: global_store } if File.directory?(global_store)
+  %w[plastic knowdb].each do |slug|
+    store = File.join(plastic_home, "projects", slug, "store")
+    list << { key: "project:#{slug}", store: store } if File.directory?(store)
+  end
+  list
+end
 
-  lines = content.lines
-  idx = lines.index { |l| l.strip == "## Links" }
-  return unless idx
+# Build the cross-store maps the LinksProjection resolver needs:
+#   store_index    => { store_key => [bare ids] }
+#   node_index     => { store_key => { id => { basename:, label: } } }
+#   relocation_map => from GraphRebuild.build_relocation_map over every INDEX.md
+# `fallback_store` is the store the new intent lives in; it is always included so
+# resolution works even for a brand-new store with no INDEX.md yet.
+def build_cross_store_maps(plastic_home, fallback_store_key, fallback_store_dir)
+  stores = family_stores(plastic_home)
+  # Ensure the fallback store is represented even if family discovery missed it.
+  unless stores.any? { |s| s[:key] == fallback_store_key }
+    stores << { key: fallback_store_key, store: fallback_store_dir }
+  end
+
+  store_index = Hash.new { |h, k| h[k] = [] }
+  node_index = Hash.new { |h, k| h[k] = {} }
+  index_texts = {}
+
+  stores.each do |s|
+    next unless File.directory?(s[:store])
+
+    Dir.children(s[:store]).reject { |e| e.start_with?(".") }.sort.each do |entry|
+      dir = File.join(s[:store], entry)
+      next unless File.directory?(dir)
 
-  insert_at = lines.length
-  ((idx + 1)...lines.length).each do |j|
-    if lines[j].strip.start_with?("## ")
-      insert_at = j
-      break
+      md = File.join(dir, "#{entry}.md")
+      next unless File.exist?(md)
+
+      fm = IntentValidator.parse_frontmatter(md)
+      next unless fm.is_a?(Hash) && fm["id"]
+
+      id = fm["id"].to_s
+      store_index[s[:key]] << id
+      node_index[s[:key]][id] = { basename: entry, label: fm["intent"].to_s.strip }
     end
+
+    idx = File.join(File.dirname(s[:store]), "INDEX.md")
+    index_texts[s[:key]] = File.read(idx) if File.exist?(idx)
   end
-  lines.insert(insert_at, "#{link_line}\n")
-  File.write(file_path, lines.join)
+
+  relocation_map = GraphRebuild.build_relocation_map(index_texts)
+  { store_index: store_index, node_index: node_index, relocation_map: relocation_map }
+end
+
+# Re-project ONE intent file's `## Links` as the canonical I5 projection of its
+# OWN frontmatter sources+chain, using the shared cross-store resolver. Writes the
+# file only if the section changed (idempotent). Born-canonical: a fresh root with
+# no edges gets the empty-state comment; the fence-aware rewriter touches only the
+# real `## Links` section. Returns true on success, false when the intent could
+# not be read or a ref was unresolvable (left unwritten, never a guessed link).
+def project_links_for(file_path, referer_store_key, maps)
+  return false unless File.exist?(file_path)
+
+  content = File.read(file_path)
+  fm = IntentValidator.parse_frontmatter_text(content)
+  return false unless fm.is_a?(Hash)
+
+  resolve = lambda do |ref|
+    LinksProjection.resolve_ref_projection(
+      ref,
+      referer_store: referer_store_key,
+      relocation_map: maps[:relocation_map],
+      store_index: maps[:store_index],
+      node_index: maps[:node_index]
+    )
+  end
+
+  begin
+    section_text = LinksProjection.section(
+      sources: Array(fm["sources"]).map(&:to_s),
+      chain: Array(fm["chain"]).map(&:to_s),
+      resolve: resolve
+    )
+    updated = LinksSection.rewrite(content, section_text)
+  rescue LinksProjection::UnresolvedRef, LinksSection::AmbiguousLinks => e
+    warn "new-intent: could not project ## Links for #{File.basename(file_path)}: #{e.message}"
+    return false
+  end
+
+  File.write(file_path, updated) if updated != content
+  true
 end
 
 def main(argv)
@@ -176,8 +273,9 @@ def main(argv)
   # 4a. I1 reciprocity: write the child's id into EACH source intent's frontmatter
   # `chain` (the formative-reciprocity backlink), for BOTH the `--parent` and the
   # `--sources` path. `sources` is the redundant-explicit set from step 3 (it already
-  # folds in `--parent`). Scope boundary: 68 fixes ONLY the frontmatter `chain`
-  # backlink; the `## Links` wikilink projection for the `--sources` path is intent 72.
+  # folds in `--parent`). Collect the touched source files so their `## Links` can be
+  # re-projected once the chain edges are on disk.
+  source_files = []
   sources.each do |src_id|
     next if src_id.nil? || src_id.empty?
 
@@ -186,19 +284,22 @@ def main(argv)
 
     src_file = File.join(src_dir, "#{File.basename(src_dir)}.md")
     add_to_chain(src_file, id)
+    source_files << src_file
   end
 
-  # 4b. Reciprocal `## Links` wikilinks: forward link to parent + back-reference in
-  # the parent (kept parent-only; the `--sources` path's wikilink is intent 72's scope).
-  if opts[:parent] && !opts[:parent].empty?
-    parent_id = opts[:parent]
-    append_link(intent_file, "- [[#{parent_id}]]")
-    parent_dir = Dir.glob(File.join(store, "#{parent_id}--*")).find { |d| File.directory?(d) }
-    if parent_dir
-      parent_file = File.join(parent_dir, "#{File.basename(parent_dir)}.md")
-      append_link(parent_file, "- [[#{id}]]")
-    end
-  end
+  # 4b. Canonical `## Links` projection (intent 72): born-canonical, drift PREVENTED
+  # at the source. Build the cross-store resolver maps AFTER the chain backlinks are
+  # written, then project the NEW intent's Links from its own frontmatter (sources at
+  # birth, chain empty) and RE-project each source/parent's Links (it just gained the
+  # new id in its chain). The fence-aware rewriter and the resolved-target dedup are
+  # the same ones project-links and the doctor check use, so a freshly created intent
+  # and its sources both PASS graph_links_projection. A no-source root gets the
+  # canonical empty-state comment.
+  plastic_home, referer_store_key = store_context(store)
+  maps = build_cross_store_maps(plastic_home, referer_store_key, store)
+
+  project_links_for(intent_file, referer_store_key, maps)
+  source_files.uniq.each { |sf| project_links_for(sf, referer_store_key, maps) }
 
   # 5. Sentinel placeholders for each lifecycle file. The sentinel is the FIRST
   # line; the rendered template body follows so the file is a usable starting
@@ -210,7 +311,15 @@ def main(argv)
     File.write(File.join(intent_dir, name), "#{Bridge::PLACEHOLDER_SENTINEL}\n#{body}")
   end
 
-  # 6. Self-validate (frontmatter + sanctioned sections).
+  # 6. Stamp the born savepoint line (intent 81). The first ledger line is the
+  # `What` bookend, written deterministically at creation rather than relying on
+  # a PostToolUse gate firing on the intent-file write (which is missed in some
+  # sessions / harnesses). The intent file is never a sentinel placeholder, so
+  # append_savepoint records `What  {id}--{slug}.md`. Idempotent: a later gate
+  # fire adds nothing.
+  Bridge.append_savepoint(intent_dir, intent_file)
+
+  # 7. Self-validate (frontmatter + sanctioned sections).
   result = IntentValidator.validate(intent_dir)
   unless result[:ok]
     warn "new-intent: scaffolded intent is NOT born complete:"

package/scripts/plastic-lock

@@ -0,0 +1,164 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+#
+# plastic-lock: inspect and repair the durable delivery lock (intent 108, D5),
+# and take/free per-artifact claim tokens (intent 111 D1/D5).
+#
+# Usage: plastic-lock <status|fix|release|reclaim|delegate|claim|release-claim>
+#          [--intent-dir DIR] [--session SID] [--delegate SID] [--artifact NAME]
+#
+# Verbs:
+#   status        report the lock file, the bridge cache, their agreement,
+#                 and any live per-artifact claims
+#   fix           idempotent repair: rebuild lock + bridge from disk truth for
+#                 the current session; never touches a fresh foreign lock
+#   release       owner clears the lock (End tail / abandoning a boarding)
+#   reclaim       explicit takeover of a stale lock, audited in savepoint.md
+#   delegate      owner registers a subagent session under the lock (D4)
+#   claim         acquire the named --artifact's claim token (intent 111);
+#                 rejected (exit 1) while a fresh claim is held by anyone,
+#                 including this same session; takes over a stale claim
+#   release-claim free the named --artifact's claim token
+#
+# Without --intent-dir the intent is resolved from this session's bridge.
+# Exit 0 on success/report; exit 1 when the verb is blocked (held elsewhere).
+
+require "json"
+require_relative "lib/bridge"
+require_relative "lib/lock"
+
+def usage!
+  warn "usage: plastic-lock <status|fix|release|reclaim|delegate|claim|release-claim> " \
+       "[--intent-dir DIR] [--session SID] [--delegate SID] [--artifact NAME]"
+  exit 1
+end
+
+verb = ARGV.shift
+usage! unless %w[status fix release reclaim delegate claim release-claim].include?(verb)
+
+opts = {}
+until ARGV.empty?
+  case (flag = ARGV.shift)
+  when "--intent-dir" then opts[:dir] = ARGV.shift
+  when "--session" then opts[:session] = ARGV.shift
+  when "--delegate" then opts[:delegate] = ARGV.shift
+  when "--artifact" then opts[:artifact] = ARGV.shift
+  else
+    warn "unknown flag #{flag}"
+    usage!
+  end
+end
+
+session = opts[:session]
+session = ENV["CLAUDE_CODE_SESSION_ID"] if session.nil? || session.strip.empty?
+
+dir = opts[:dir]
+if dir.nil? || dir.strip.empty?
+  bridge = Bridge.discover_bridge(session: session, cwd: Dir.pwd)
+  dir = Bridge.bridge_intent_dir(bridge)
+end
+if dir.nil?
+  warn "plastic-lock: no intent resolved; pass --intent-dir <intent dir>"
+  exit 1
+end
+dir = File.expand_path(dir)
+
+intent_id = Bridge.intent_id_from_dir(dir)
+store = File.dirname(dir)
+name = File.basename(dir)
+key = Bridge.resolve_session(session, intent_id: intent_id, store: store)
+
+case verb
+when "status"
+  lock = Lock.read(dir)
+  bridge = Bridge.read(key, intent_id: intent_id)
+  report = {
+    "intent_dir" => dir,
+    "session" => key,
+    "lock" => lock,
+    "lock_fresh" => Lock.fresh?(dir),
+    "lock_corrupt" => Lock.corrupt?(dir),
+    "bridge_present" => !bridge.nil?,
+    "agreement" => (lock && bridge) ?
+      (lock["owner_session"] == bridge.dig("lock", "owner_session")) : nil,
+    "claims" => Claim.claims_status(dir),
+  }
+  puts JSON.pretty_generate(report)
+when "fix"
+  report = Bridge.repair_lock(key, intent_id: intent_id, intent_dir: dir,
+                              store: store, name: name)
+  puts JSON.pretty_generate(report)
+  unless report["status"] == "repaired"
+    warn "plastic-lock: #{report['status']} by #{report['owner']}" \
+         "#{report['hint'] ? " (#{report['hint']})" : ''}"
+    exit 1
+  end
+when "release"
+  result = Lock.release(dir, session: key)
+  if result == :not_owner
+    warn "plastic-lock: not the owner; run plastic-lock status"
+    exit 1
+  end
+  data = Bridge.read(key, intent_id: intent_id)
+  if data
+    data["lock"] = { "owner_session" => nil, "acquired_at" => nil,
+                     "host" => nil, "type" => nil, "delegates" => [] }
+    Bridge.write(key, data)
+  end
+  puts "released (#{result})"
+when "reclaim"
+  status, lock_data = Lock.takeover(dir, session: key)
+  if status == :fresh
+    warn "plastic-lock: lock is FRESH and held by #{lock_data['owner_session']}; " \
+         "back off (no silent reclaim)"
+    exit 1
+  end
+  report = Bridge.repair_lock(key, intent_id: intent_id, intent_dir: dir,
+                              store: store, name: name)
+  puts JSON.pretty_generate(report)
+when "delegate"
+  usage! if opts[:delegate].nil?
+  ok = Lock.add_delegate(dir, delegate: opts[:delegate], session: key)
+  unless ok
+    warn "plastic-lock: only the lock owner may delegate; run plastic-lock status"
+    exit 1
+  end
+  puts "delegated #{opts[:delegate]} under #{key}"
+when "claim"
+  usage! if opts[:artifact].nil?
+  status, data = Claim.acquire_claim(dir, opts[:artifact], session: key,
+                                     delegate: opts[:delegate])
+  case status
+  when :acquired
+    puts "claimed #{opts[:artifact]} under #{key}"
+  when :held
+    warn "plastic-lock: #{opts[:artifact]} is claimed by " \
+         "#{data['owner_session']} since #{data['acquired_at']}; back off"
+    exit 1
+  when :stale
+    old = data && data["owner_session"]
+    Claim.release_claim(dir, opts[:artifact], session: key, force: true)
+    status2, = Claim.acquire_claim(dir, opts[:artifact], session: key,
+                                   delegate: opts[:delegate])
+    if status2 == :acquired
+      warn "plastic-lock: took over stale claim on #{opts[:artifact]} from #{old}"
+      puts "claimed #{opts[:artifact]} under #{key}"
+    else
+      warn "plastic-lock: could not take over #{opts[:artifact]} (#{status2})"
+      exit 1
+    end
+  when :corrupt
+    Claim.release_claim(dir, opts[:artifact], session: key, force: true)
+    Claim.acquire_claim(dir, opts[:artifact], session: key, delegate: opts[:delegate])
+    puts "claimed #{opts[:artifact]} under #{key} (repaired corrupt claim)"
+  end
+when "release-claim"
+  usage! if opts[:artifact].nil?
+  result = Claim.release_claim(dir, opts[:artifact], session: key)
+  if result == :not_owner
+    warn "plastic-lock: not the claim owner; run plastic-lock status"
+    exit 1
+  end
+  puts "released-claim #{opts[:artifact]} (#{result})"
+end