@zalom/plastic 2.0.1 → 2.0.3

package/scripts/lib/runner_dispatch.rb

@@ -46,9 +46,9 @@ module RunnerDispatch
 
   HARD_CAP_RE = /\Ais at its dispatch cap \((\d+)\/(\d+)\)\z/.freeze
 
-  # D8 (355, n6): the agent every dispatched, non-decision node names - a
-  # role, never a harness (matrix 6.5), and never a consultation advisor, which
-  # stays a deliberate, never-auto-dispatched consultation agent.
+  # The spawn block's default agent. A dispatched node names its own kind's
+  # node agent instead (HarnessAdapter.agent_type_for_kind), the same agent
+  # the dispatch line under it names (acceptance N12).
   SPAWN_AGENT = "plastic-executor"
 
   # matrix 6.1/6.2: one spawn block per dispatched node - agent, the model
@@ -237,7 +237,8 @@ module RunnerDispatch
     provisioned = RunnerPolicy.worktree?(kind) ? worktree.provision(context, node: node, kind: kind, runner: runner)
                                                 : unprovisioned
     node_reader = lambda do |intent_dir:|
-      { "code" => provisioned[:path], "code_branch" => provisioned[:branch], "provisioned" => !!provisioned[:provisioned] }
+      { "code" => provisioned[:path], "code_branch" => provisioned[:branch], "provisioned" => !!provisioned[:provisioned],
+        "read_only" => !RunnerPolicy.worktree?(kind) }
     end
 
     # Row 5.18: build the node input BEFORE writing `running` - a `running` line
@@ -289,7 +290,7 @@ module RunnerDispatch
 
     test_command = NodeInput.test_command_block(intent_dir: intent_dir, files: (nodes_decl[node] || {})[:files])
     spawn = spawn_block(model: model, effort: effort, input: build_result[:path], test_command: test_command,
-                        call_cap: calls_cap)
+                        call_cap: calls_cap, agent: HarnessAdapter.agent_type_for_kind(kind))
 
     {
       ok: true,
@@ -409,9 +410,9 @@ module RunnerDispatch
   end
 
   # Row 5.32: re-arms delivery.lock for a resumed session with a new id -
-  # `plastic-lock arm` is the shipped command that takes ownership again.
+  # `plastic auto take` is the public command that takes ownership again.
   def rearm_command(intent_dir)
-    "plastic-lock arm --intent-dir #{intent_dir}"
+    "plastic auto take #{File.basename(intent_dir.to_s).split("--").first}"
   end
 
   # --- refusals and the report -------------------------------------------------

package/scripts/lib/session_git.rb

@@ -7,6 +7,7 @@ require_relative "worktree"
 require_relative "scaffold_intent"
 require_relative "session_ledger"
 require_relative "active_delivery"
+require_relative "lock"
 
 # SessionGit - the branch model and per-repo flow settings behind
 # `scripts/session-commit` (intent 300), which is how a checklist item
@@ -306,6 +307,44 @@ module SessionGit
     parts.each_cons(2).any? { |a, b| a == ".claude" && b == "worktrees" }
   end
 
+  # Why an agent-owned branch was left alone, named from the real delivery
+  # lock (acceptance N5). The branch or worktree name gives the intent id; the
+  # repository's slug in projects.yml gives its store. A branch whose intent
+  # cannot be found is still left alone, and says so plainly.
+  def delivery_state(repo, branch, plastic_home, session)
+    intent_dir = delivery_intent_dir(repo, branch, plastic_home)
+    return "it is an intent delivery branch" if intent_dir.nil?
+
+    id = File.basename(intent_dir)[/\A\d+/]
+    owner = Lock.read(intent_dir).to_h["owner_session"].to_s
+    return "it is intent #{id}'s delivery branch and no delivery lock is held" if owner.empty?
+    if !blank?(session) && owner.start_with?(session.to_s)
+      return "this session holds intent #{id}'s delivery lock; commit delivery work there with git"
+    end
+
+    "intent #{id}'s delivery lock is held by #{owner}"
+  end
+
+  def delivery_intent_dir(repo, branch, plastic_home)
+    parts = File.expand_path(repo.to_s).split(File::SEPARATOR)
+    at = parts.each_cons(2).find_index { |a, b| a == ".claude" && b == "worktrees" }
+    name = branch.to_s.start_with?("plastic/") ? branch.to_s.delete_prefix("plastic/") : parts.last
+    main = at ? parts[0...at].join(File::SEPARATOR) : File.expand_path(repo.to_s)
+    id = name[/\A(\d+)--/, 1]
+    slug = slug_for_repo(main, plastic_home)
+    return nil if id.nil? || slug.nil?
+
+    Dir.glob(File.join(Plastic::StoreLayout.root(plastic_home, slug), "store", "#{id}--*")).first
+  end
+
+  def slug_for_repo(main, plastic_home)
+    projects = YAML.safe_load_file(File.join(plastic_home, "projects.yml")).fetch("projects")
+    target = File.realpath(main)
+    projects.find { |_slug, info| File.exist?(info["path"].to_s) && File.realpath(info["path"]) == target }&.first
+  rescue StandardError
+    nil
+  end
+
   def stage_and_commit(dir, subject, runner:, body: nil)
     runner.run("-C", dir, "add", "-A")
     args = ["-C", dir, "commit", "-m", subject]
@@ -340,7 +379,9 @@ module SessionGit
 
     branch_now = current_branch(repo, runner: runner)
     return note("detached HEAD: no commit") if branch_now == "HEAD"
-    return note("left branch #{branch_now} untouched: agent lock") if agent_owned?(repo, branch_now)
+    if agent_owned?(repo, branch_now)
+      return note("left branch #{branch_now} untouched: #{delivery_state(repo, branch_now, plastic_home, session)}")
+    end
     return note("repository has no commits yet: no commit") unless has_commits?(repo, runner: runner)
 
     flow, flow_notes = load_flow(cwd: cwd, repo: repo, plastic_home: plastic_home, runner: runner)

package/scripts/lib/untouched_scaffold.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "savepoint"
+require_relative "backfill_intent"
+
+# Finds an intent that is still exactly what new-intent created, so
+# end-intent can refuse to close it as delivered.
+#
+# The rule is narrow so older intents still close. An intent is untouched
+# only when all of these hold:
+#
+#   - spec.md, plan.md, checklist.md and outcome.md exist and are still
+#     unedited placeholders, with no ticked checklist item;
+#   - there is no action, node or graph file;
+#   - savepoint.md holds only What lines;
+#   - the code worktree, if there is one, has no changes.
+#
+# An older intent with missing files is never untouched.
+module UntouchedScaffold
+  module_function
+
+  LIFECYCLE = %w[spec.md plan.md checklist.md outcome.md].freeze
+  SCAFFOLD_LINE = /\A\S+\s+What\s/
+  TICKED_ITEM = /^\s*- \[[xX]\] /
+
+  def reason(intent_dir, templates: {}, worktree_changed: ->(_dir) { false })
+    return nil unless placeholders_untouched?(intent_dir, templates)
+    return nil if Savepoint.has_real_action?(intent_dir)
+    return nil if File.exist?(File.join(intent_dir, "graph.md"))
+    return nil unless scaffold_savepoint?(File.join(intent_dir, "savepoint.md"))
+    return nil if worktree_changed.call(intent_dir)
+
+    "spec.md, plan.md, checklist.md and outcome.md are still placeholders, " \
+      "no action, node or graph was written, the savepoint records no work, " \
+      "and the code worktree has no changes"
+  end
+
+  def placeholders_untouched?(intent_dir, templates)
+    paths = LIFECYCLE.map { |rel| File.join(intent_dir, rel) }
+    return false unless paths.all? { |path| File.exist?(path) && !Savepoint.stage_file_present?(path) }
+    return false if File.read(File.join(intent_dir, "checklist.md")).match?(TICKED_ITEM)
+
+    BackfillIntent.classify(intent_dir, templates: templates)[:edited].empty?
+  end
+
+  def scaffold_savepoint?(path)
+    return false unless File.exist?(path)
+
+    File.readlines(path).reject { |line| line.strip.empty? }.all? { |line| line.match?(SCAFFOLD_LINE) }
+  end
+end

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

package/skills/_decision-tables.md

@@ -1,10 +1,10 @@
 ## Numbered Decision Tables
 
 The shared procedure for collecting owner rulings during any stage (Why, How, Exec).
-Any stage skill that needs the owner to choose between options or rule on a batch of
-open questions follows this procedure instead of improvising its own format.
+An agent that needs the owner to choose between options or rule on a batch of open
+questions follows this procedure instead of improvising its own format.
 
-Read this when a stage skill's own text says to.
+The installer copies this file to `~/.plastic/_decision-tables.md`.
 
 ### The procedure