@zalom/plastic 2.0.1 → 2.0.2

package/scripts/plastic-lock

@@ -15,8 +15,9 @@
 #   arm           take the intent for this session (intent 307): acquire
 #                 delivery.lock stamped with --mode (default auto) and the
 #                 provenance flags, provision the code worktree, and point the
-#                 session at the intent; exit 1 on a held, stale, excluded, or
-#                 corrupt lock with the resolving doctor hint
+#                 session at the intent; exit 3 on a held, stale, or excluded
+#                 lock (another owner's), exit 1 on a corrupt one, each with the
+#                 public command that resolves it
 #   who           compact, read-only durable owner/activity view
 #   status        report the lock file, its freshness, the derived worktree,
 #                 whether this session is the one delivering the intent, and
@@ -36,7 +37,8 @@
 # configured project roots): exactly one fresh lock this session owns or
 # delegates for. Session resolution no longer reads any per-session state
 # file; that path was retired in 2.0 (intent 307) and 344 G11.
-# Exit 0 on success/report; exit 1 when the verb is blocked.
+# Exit 0 on success/report; exit 3 when another session owns the lock (arm,
+# fix, release, reclaim); exit 1 when the verb is otherwise blocked.
 
 require_relative "lib/store_layout"
 require "json"
@@ -82,7 +84,6 @@ usage! if opts[:mode] && !%w[auto guided].include?(opts[:mode])
 session = opts[:session]
 session = ENV["CLAUDE_CODE_SESSION_ID"] if session.nil? || session.strip.empty?
 harness = opts[:harness]
-hint_harness = harness || "claude"
 # The plastic home every hook uses (PLASTIC_HOME, else ~/.plastic); Arm takes the
 # OS home above it, the same convention Worktree resolves projects.yml from.
 plastic_home_env = ENV["PLASTIC_HOME"].to_s.strip
@@ -149,8 +150,11 @@ intent_id = Arm.intent_id_for(dir)
 store = File.dirname(dir)
 key = Arm.resolve_session(session, store: store, intent_id: intent_id)
 
-def doctor_hint(verb_text, harness)
-  "run #{Lock.skill_ref('plastic-doctor', harness: harness)} #{verb_text}"
+# Exit 3 is Plastic's refusal: the lock belongs to another session, and only
+# its owner (or the person who owns the work) may resolve it.
+def refuse(message)
+  warn "plastic-lock: #{message}"
+  exit 3
 end
 
 case verb
@@ -167,19 +171,16 @@ when "arm"
       "worktree" => wt
     )
   when :held
-    warn "plastic-lock: delivery lock for intent #{intent_id} is held by session " \
-         "#{result[:lock] && result[:lock]['owner_session']}; #{doctor_hint('check the lock status', hint_harness)}"
-    exit 1
+    refuse "delivery lock for intent #{intent_id} is held by session " \
+           "#{result[:lock] && result[:lock]['owner_session']}; plastic auto lock status #{intent_id} shows it"
   when :stale
-    warn "plastic-lock: delivery lock for intent #{intent_id} is stale (owner " \
-         "#{result[:lock] && result[:lock]['owner_session']}); #{doctor_hint('reclaim the lock to take it over with an audit', hint_harness)}"
-    exit 1
+    refuse "delivery lock for intent #{intent_id} is stale (owner " \
+           "#{result[:lock] && result[:lock]['owner_session']}); #{Arm.stale_hint(intent_id)}"
   when :excluded
-    warn "plastic-lock: a #{result[:lock] && result[:lock]['type']} lock is active on intent " \
-         "#{intent_id}; #{doctor_hint('check the lock status', hint_harness)}"
-    exit 1
+    refuse "a #{result[:lock] && result[:lock]['type']} lock is active on intent " \
+           "#{intent_id}; plastic auto lock status #{intent_id} shows it"
   when :corrupt
-    warn "plastic-lock: delivery.lock for intent #{intent_id} is unreadable; #{doctor_hint('fix the lock', hint_harness)}"
+    warn "plastic-lock: delivery.lock for intent #{intent_id} is unreadable; plastic auto lock fix #{intent_id} rewrites it"
     exit 1
   when :inline_refused
     warn "plastic-lock: refusing to arm intent #{intent_id} from a conversation session " \
@@ -207,32 +208,27 @@ when "status"
 when "fix"
   report = Arm.repair(intent_dir: dir, session: key, home: home, harness: harness,
                       agent: opts[:agent], model: opts[:model], thread: opts[:thread],
-                      run_mode: opts[:mode], hint_harness: hint_harness)
+                      run_mode: opts[:mode])
   puts JSON.pretty_generate(report)
   unless report["status"] == "repaired"
-    warn "plastic-lock: #{report['status']} by #{report['owner']}" \
-         "#{report['hint'] ? " (#{report['hint']})" : ''}"
-    exit 1
+    refuse "#{report['status']} by #{report['owner']}" \
+           "#{report['hint'] ? " (#{report['hint']})" : ''}"
   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
+  refuse "not the owner; plastic auto lock status #{intent_id} shows who is" if result == :not_owner
   puts "released (#{result})"
 when "reclaim"
   status, lock_data = Lock.takeover(dir, session: key, harness: harness,
                                     agent: opts[:agent], model: opts[:model],
                                     thread: opts[:thread], run_mode: opts[:mode])
   if status == :fresh
-    warn "plastic-lock: lock is FRESH and held by #{lock_data['owner_session']}; " \
-         "back off (no silent reclaim)"
-    exit 1
+    refuse "lock is FRESH and held by #{lock_data['owner_session']}; " \
+           "back off (no silent reclaim)"
   end
   report = Arm.repair(intent_dir: dir, session: key, home: home, harness: harness,
                       agent: opts[:agent], model: opts[:model], thread: opts[:thread],
-                      run_mode: opts[:mode], hint_harness: hint_harness)
+                      run_mode: opts[:mode])
   puts JSON.pretty_generate(report)
 when "delegate"
   usage! if opts[:delegate].nil?

package/scripts/project-links

@@ -48,10 +48,6 @@ require_relative "lib/revisions_writer"
 class ProjectLinks
   DEFAULT_HOME = File.join(Dir.home, ".plastic")
 
-  # The 72 intent dir audit destination (relative to plastic_home).
-  DEFAULT_AUDIT_REL =
-    "projects/plastic/store/72--links-graph-projection/resources/audit--links-projection.md"
-
   def initialize(plastic_home: DEFAULT_HOME, dry_run: false, audit_path: nil,
                  drop_unbacked_links: false, intent: nil, store: nil)
     @plastic_home = plastic_home
@@ -60,20 +56,7 @@ class ProjectLinks
     @intent = intent && intent.to_s
     @store = store
 
-    # A dry run must NOT stomp the canonical audit (humans run --dry-run to review
-    # the plan). With no explicit --audit-path, a dry run writes a `.dry-run.md`
-    # sibling, leaving the canonical real-run audit untouched. An explicit
-    # --audit-path is always honored verbatim (tests inject it). Mirrors
-    # RebuildGraph's discipline exactly.
-    canonical = File.join(plastic_home, DEFAULT_AUDIT_REL)
-    @audit_path =
-      if audit_path
-        audit_path
-      elsif dry_run
-        canonical.sub(/\.md\z/, ".dry-run.md")
-      else
-        canonical
-      end
+    @audit_path = audit_path || File.join(Plastic::StoreLayout.global_root(plastic_home), "resources", "audit--links-projection.md")
   end
 
   attr_reader :plastic_home, :dry_run, :audit_path, :drop_unbacked_links, :intent, :store
@@ -330,9 +313,11 @@ class ProjectLinks
     "(ambiguous: multiple ## Links headings)"
   end
 
-  # Always write the audit (even in dry-run, so the human reviews the plan).
+  # Return the audit for previews; save it only when applying changes.
   def emit_audit(store_list, results)
     text = render_audit(store_list, results)
+    return text if dry_run
+
     FileUtils.mkdir_p(File.dirname(audit_path))
     File.write(audit_path, text)
     text
@@ -348,7 +333,7 @@ class ProjectLinks
 
   def render_audit(store_list, results)
     lines = []
-    lines << "# Audit: store-wide ## Links projection (intent 72)"
+    lines << "# Audit: store-wide Links projection"
     lines << ""
     lines << "Generated: #{Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ")}#{dry_run ? " (DRY RUN)" : ""}"
     lines << "Scoped to intent #{intent} only (--intent)." if intent
@@ -482,6 +467,6 @@ if $PROGRAM_NAME == __FILE__
        "regenerated #{totals[:regenerated]}, added #{totals[:added]}, " \
        "unchanged #{totals[:unchanged]}, failed #{totals[:failed]} " \
        "across #{results.size} store(s)."
-  puts "Audit: #{tool.audit_path}"
+  puts(dry ? "Dry run: no files written." : "Audit: #{tool.audit_path}")
   exit 1 if tool.any_failed?(results)
 end

package/scripts/roadmap-graph

@@ -62,6 +62,7 @@ module RoadmapGraphCli
     end
     if result[:cycle]
       warn "roadmap-graph check: cyclic graph: #{result[:cycle].join(' > ')}"
+      warn_dangling(result[:dangling])
       return 1
     end
     if result[:reason]
@@ -73,14 +74,19 @@ module RoadmapGraphCli
     puts "Ready: #{result[:ready].join(', ')}"
     puts "Dead ends: #{result[:dead_ends].join(', ')}" unless result[:dead_ends].empty?
 
-    unless result[:dangling].empty?
-      warn "roadmap-graph check: graph names #{result[:dangling].map(&:inspect).join(', ')}, no batch entry"
-      return 1
-    end
+    return 1 if warn_dangling(result[:dangling])
 
     0
   end
 
+  # Names every graph id no batch lists; true when there was one.
+  def warn_dangling(dangling)
+    return false if dangling.to_a.empty?
+
+    warn "roadmap-graph check: graph names #{dangling.map(&:inspect).join(', ')}, no batch entry"
+    true
+  end
+
   def render(path, dry_run)
     result = RoadmapRender.write(path, dry_run: dry_run)
     unless result[:ok]

package/scripts/rollback.rb

@@ -89,12 +89,16 @@ class Rollback < InstallerCore
   end
 
   def switch_to(target, current)
+    return 3 if refuse_incompatible_store_layout(target)
+
     action = action_for(target, current)
     puts "#{action == "downgrade" ? "\u{23ea}" : "\u{23e9}"}  #{current} \u{2192} #{target} (#{action})"
     prepare_switch(target, current)
     cmd = ["npx", "#{PKG}@#{target}", "install", "--reinstall", "--ledger-action", action, *harness_flags]
     puts "  $ #{cmd.join(" ")}"
-    system(*cmd) ? 0 : 1
+    return 1 unless system({"PLASTIC_PACKAGE_ROOT" => nil}, *cmd)
+
+    installed_version == target ? 0 : 1
   end
 
   # Before handing off to an older package (a downgrade), strip Plastic's own current hook

package/scripts/update.rb

@@ -62,6 +62,8 @@ class Update < InstallerCore
       warn "No published version on the #{requested} channel."
       return 1
     when :ok
+      return 3 if refuse_incompatible_store_layout(res[:target])
+
       if res[:kind] == :cross_bleeding && !confirm_bleeding(iv, res[:target], argv)
         puts "Aborted."
         return 1
@@ -235,10 +237,14 @@ class Update < InstallerCore
   # the target version's install verb, recording the ledger action as `update`. On
   # success, commits the re-synced core files and clears the update-check cache
   # (former update skill, lines 124-125).
-  def perform_switch(target, agent_flags, switch_runner: ->(cmd) { system(*cmd) })
+  def perform_switch(target, agent_flags, switch_runner: ->(cmd) { system({"PLASTIC_PACKAGE_ROOT" => nil}, *cmd) })
     cmd = ["npx", "#{PKG}@#{target}", "install", "--reinstall", "--ledger-action", "update", *agent_flags]
     puts "  $ #{cmd.join(" ")}"
     return 1 unless switch_runner.call(cmd)
+    unless installed_version == target
+      warn "Update did not install #{target}; installed version is #{installed_version.inspect}."
+      return 1
+    end
 
     commit_core_files(target)
     clear_update_check_cache