@zalom/plastic 2.0.0-alpha.20 → 2.0.0-alpha.22

package/scripts/insight-append

@@ -11,8 +11,16 @@
 # `now:` seam is the test seam; the CLI uses the default Time.now, which is fine
 # because determinism is covered at the library level (test/insights_test.rb).
 #
+# --rule (intent 341, G8, C37): tags the entry as a rule, not just an
+# observation, by prepending the literal "rule: " onto the text before it
+# ever reaches Insights.append_insight; the library itself stays untouched,
+# since a tag is a text-level convention, not a new field on the ledger.
+# Doctor's unpromoted_rules check (scripts/doctor.rb) later lists any tagged
+# entry whose exact text no skills/conventions/references/*.md chapter
+# carries yet.
+#
 # Usage:
-#   insight-append <intent_dir> <text> --stage S --author A
+#   insight-append <intent_dir> <text> --stage S --author A [--rule]
 #
 # Exit codes: 0 (entry appended), 2 (usage).
 
@@ -21,6 +29,7 @@ require_relative "lib/insights"
 def parse_args(argv)
   stage = nil
   author = nil
+  rule = false
   positional = []
   i = 0
   while i < argv.length
@@ -31,21 +40,26 @@ def parse_args(argv)
     when "--author"
       author = argv[i + 1]
       i += 2
+    when "--rule"
+      rule = true
+      i += 1
     else
       positional << argv[i]
       i += 1
     end
   end
-  [positional[0], positional[1], stage, author]
+  [positional[0], positional[1], stage, author, rule]
 end
 
-intent_dir, text, stage, author = parse_args(ARGV)
+intent_dir, text, stage, author, rule = parse_args(ARGV)
 
 if [intent_dir, text, stage, author].any? { |v| v.nil? || v.to_s.empty? }
-  warn "usage: insight-append <intent_dir> <text> --stage S --author A"
+  warn "usage: insight-append <intent_dir> <text> --stage S --author A [--rule]"
   exit 2
 end
 
+text = "rule: #{text}" if rule
+
 entry = Insights.append_insight(File.expand_path(intent_dir), text,
                                 stage: stage, author: author)
 puts "appended: #{entry}"

package/scripts/lib/compact_instructions.rb

@@ -19,9 +19,9 @@ require "digest"
 #
 # Library only: no CLI, no ENV, no I/O.
 module CompactInstructions
-  # 35 and 50 percent of a 1M window.
-  OFFER_TOKENS = 350_000
-  INSIST_TOKENS = 500_000
+  # 15 and 25 percent of a 1M window (intent 355, n5, D7).
+  OFFER_TOKENS = 150_000
+  INSIST_TOKENS = 250_000
 
   # Static on purpose. A body rendered from the user's config would change its hash
   # every time they edited config.yml, and doctor would then report a correct install
@@ -32,10 +32,10 @@ module CompactInstructions
     Plastic watches this session's context. When the harness reports how much of the
     window is used:
 
-    - At 350,000 tokens, offer to compact. Say that the hand-off in today's day ledger
+    - At 150,000 tokens, offer to compact. Say that the hand-off in today's day ledger
       is written and current, and take no for an answer: a task that is nearly done
       does not need the interruption.
-    - At 500,000 tokens, insist. Take no new work, write the hand-off in today's day
+    - At 250,000 tokens, insist. Take no new work, write the hand-off in today's day
       ledger, and compact before continuing.
     - After a compaction, say continue. The day summary at boot and the hand-off carry
       the state; do not rebuild it by re-reading files.

package/scripts/lib/doctor_core.rb

@@ -30,7 +30,8 @@ class Doctor
   # The Claude events hooks_registered expects in settings.json: the six-event map of
   # cut-inventory 3b (intent 309 added SessionEnd, registered for close since intent 301;
   # intent 316a added MessageDisplay, registered for message-display, Claude only).
-  CLAUDE_HOOK_EVENTS = %w[SessionStart PreCompact PostToolUse UserPromptSubmit SessionEnd MessageDisplay].freeze
+  CLAUDE_HOOK_EVENTS = %w[SessionStart PreToolUse PreCompact PostToolUse UserPromptSubmit SessionEnd
+                          MessageDisplay].freeze
 
   # Launchers the installer places in the agent's hooks dir that are NOT hooks
   # (intent 204): plastic-statusline is the settings["statusLine"] command, wired

package/scripts/lib/graph_edges.rb

@@ -118,4 +118,20 @@ module GraphEdges
     visited[node] = true
     nil
   end
+
+  # The declared work ids whose `needs` reach a verify node without passing
+  # through another verify node (343 D7), in declaration order. `kinds` maps
+  # an id to its node kind, so this module stays blind to where a kind lives.
+  def review_fixes(edges, kinds)
+    edges.keys.select { |id| kinds[id] == "work" && reaches_verify?(id, edges, kinds, {}) }
+  end
+
+  def reaches_verify?(node, edges, kinds, seen)
+    (edges[node] || []).any? do |target|
+      next false if seen[target]
+
+      seen[target] = true
+      kinds[target] == "verify" || reaches_verify?(target, edges, kinds, seen)
+    end
+  end
 end

package/scripts/lib/hook_registry.rb

@@ -34,6 +34,17 @@ module HookRegistry
           { "name" => "check-update", "status" => "" },
         ] },
       ],
+      # Intent 355, n2: the call budget guard. Not one of the edit-path
+      # gates intent 302 removed (those denied a write on content; this
+      # denies a call on a per-attempt COUNT, read from the session's own
+      # transcript, never from the tool's arguments) - see scripts/hook-
+      # call-budget. Claude only: CODEX_LIVE_STATE_EVENTS below does not
+      # carry PreToolUse, so codex_hooks_json never projects it.
+      "PreToolUse" => [
+        { "matcher" => "", "hooks" => [
+          { "name" => "call-budget", "status" => "" },
+        ] },
+      ],
       "PreCompact" => [
         { "matcher" => "", "hooks" => [
           { "name" => "savepoint", "status" => "Saving Plastic intent state..." },
@@ -75,8 +86,9 @@ module HookRegistry
   # the PostToolUse record hook collapses from Claude's multi-tool matcher onto
   # Codex's single apply_patch tool (181 F4: apply_patch is Codex's sole
   # file-mutation tool; tool_name always reports apply_patch), and the live-state
-  # events project through whole. Since intent 302 there is no PreToolUse group at
-  # all: the edit-path gates are gone on both harnesses. Command invokes the
+  # events project through whole. PreToolUse (intent 355, n2's call-budget guard,
+  # Claude only) is not one of CODEX_LIVE_STATE_EVENTS below, so Codex still
+  # carries no PreToolUse group of its own. Command invokes the
   # codex-hook dispatcher with the hook name. Guide-settled shape [guide Part 3]:
   # top-level {"hooks":{<Event>: [{"matcher","hooks":[{"type":"command","command",
   # "statusMessage"}]}]}}, identical to Claude's shape, string command. Single

package/scripts/lib/installer_core.rb

@@ -49,9 +49,9 @@ class InstallerCore
   # hand-curated pointer rather than embedding the core wholesale, and it never drifts
   # because it only ever points, never duplicates.
   CODEX_AGENTS_MD_BODY = <<~MD.freeze
-    Plastic is installed for this agent. Plastic is intent-driven state management: all
-    work flows through an intent, moved through What, Why, How, then Exec. Do not jump
-    straight to code.
+    Plastic is installed for this agent. Plastic is intent-driven state management: work runs
+    in one of three modes, direct, thinking, or auto (a team drives the runner loop:
+    `runner step`, `status`, `answer`). Do not jump straight to code.
 
     Standing rules:
     - Core conventions live in ~/.plastic/PLASTIC.md. Read it and follow it exactly. For
@@ -438,6 +438,8 @@ class InstallerCore
       "scripts/verify-intent" => "scripts/verify-intent",
       "scripts/lib/exec_worktree.rb" => "scripts/lib/exec_worktree.rb",
       "scripts/exec-worktree" => "scripts/exec-worktree",
+      "scripts/lib/session_usage.rb" => "scripts/lib/session_usage.rb",
+      "scripts/session-usage" => "scripts/session-usage",
       "scripts/doctor.rb" => "scripts/doctor.rb",
       "scripts/lib/doctor_core.rb" => "scripts/lib/doctor_core.rb",
       "scripts/lib/hook_replay.rb" => "scripts/lib/hook_replay.rb",
@@ -543,6 +545,12 @@ class InstallerCore
       # by scripts/runner's `step`.
       "scripts/lib/runner_policy.rb" => "scripts/lib/runner_policy.rb",
       "scripts/lib/runner_dispatch.rb" => "scripts/lib/runner_dispatch.rb",
+      # Intent 355 (n2): the call budget PreToolUse hook (RunnerPolicy.call_cap
+      # is its cap table, above); its launcher (hooks/call-budget) ships via
+      # hook_files' own glob, so only the hook script itself needs an entry.
+      "scripts/hook-call-budget" => "scripts/hook-call-budget",
+      "scripts/meter-watch" => "scripts/meter-watch",
+      "scripts/lib/meter_watch.rb" => "scripts/lib/meter_watch.rb",
       # Intent 340 (G7, n6): answer (closes a decision node or unparks a
       # work node parked at needs_decision), proposals (mints ids for what
       # an executor proposed), and rewind (resets the intent branch to a
@@ -564,8 +572,8 @@ class InstallerCore
       version: 3
       execution_mode: subagent-driven
       stale_threshold_days: 3
-      context_offer_tokens: 350000
-      context_insist_tokens: 500000
+      context_offer_tokens: 150000
+      context_insist_tokens: 250000
       hash_length: 6
       hash_algorithm: sha256-base36
       max_slug_words: 5

package/scripts/lib/meter_watch.rb

@@ -0,0 +1,179 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+require "time"
+require "fileutils"
+require "rbconfig"
+require_relative "atomic_write"
+
+# MeterWatch (intent 355, n5, D6): reads the owner's rate-limit cache on a
+# timer and writes one state file a session watches, instead of every session
+# parsing the cache and re-deriving the thresholds for itself. No model call
+# is spent on a tick that leaves the state unchanged.
+#
+# Everything is injected: home (holds config.yml and .cache/), the clock, the
+# cache path, and the renamer AtomicWrite uses. Nothing reads ENV, nothing
+# calls launchctl, and --install-timer (scripts/meter-watch) only ever writes
+# under the injected home.
+class MeterWatch
+  DEFAULT_REDUCE_AT = 55
+  DEFAULT_STOP_AT = 85
+  DEFAULT_WEEKLY_STOP_AT = 97
+  TICK_SECONDS = 20 * 60
+  STALE_AFTER_SECONDS = TICK_SECONDS * 2
+
+  def initialize(home:, cache_path: nil, config_path: nil, now: Time.now, renamer: File.method(:rename))
+    @home = home
+    @cache_path = cache_path || File.join(home, ".cache", "rate-limits.json")
+    @config_path = config_path || File.join(home, "config.yml")
+    @state_path = File.join(home, ".cache", "meter-state.json")
+    @now = now
+    @renamer = renamer
+    @reduce_at, @stop_at, @weekly_stop_at = load_thresholds
+  end
+
+  attr_reader :state_path
+
+  def tick
+    previous = read_state
+    state = compute_state(previous)
+    write_if_changed(previous, state)
+  end
+
+  private
+
+  def compute_state(previous)
+    return base_state("unavailable") unless File.file?(@cache_path)
+    return stopped?(previous) ? previous : base_state("stale") if stale?
+
+    cache = JSON.parse(File.read(@cache_path))
+    five_hour = cache["five_hour"]
+    seven_day = cache["seven_day"]
+    resets_at = cache["resets_at"]
+
+    # Resume compares `now` against the STOP's OWN resets_at (carried
+    # forward on `previous`, from the tick that first wrote "stop"), never
+    # the cache's current resets_at: the cache moves resets_at on to the
+    # NEXT window before five_hour/seven_day themselves drop, so comparing
+    # against the live value would never report resume (B4).
+    label = if stopped?(previous) && reset_passed?(previous["resets_at"])
+              "resume"
+            else
+              classify(five_hour, seven_day)
+            end
+
+    base_state(label, five_hour: five_hour, seven_day: seven_day, resets_at: resets_at)
+  rescue JSON::ParserError
+    base_state("unavailable")
+  end
+
+  def stopped?(previous)
+    previous && previous["state"] == "stop"
+  end
+
+  def classify(five_hour, seven_day)
+    return "stop" if five_hour.to_f >= @stop_at
+    return "stop" if seven_day.to_f >= @weekly_stop_at
+    return "reduce" if five_hour.to_f >= @reduce_at
+
+    "ok"
+  end
+
+  def stale?
+    File.mtime(@cache_path) < (@now - STALE_AFTER_SECONDS)
+  rescue Errno::ENOENT
+    true
+  end
+
+  def reset_passed?(resets_at)
+    at = parse_time(resets_at)
+    at && @now >= at
+  end
+
+  def parse_time(value)
+    return nil if value.nil? || value.to_s.empty?
+
+    text = value.to_s
+    text.match?(/\A\d+\z/) ? Time.at(text.to_i).utc : Time.iso8601(text)
+  rescue ArgumentError, TypeError
+    nil
+  end
+
+  def base_state(label, five_hour: nil, seven_day: nil, resets_at: nil)
+    {
+      "state" => label,
+      "five_hour" => five_hour,
+      "seven_day" => seven_day,
+      "resets_at" => resets_at,
+      "checked_at" => @now.getutc.iso8601,
+    }
+  end
+
+  def write_if_changed(previous, state)
+    return state if previous && previous["state"] == state["state"]
+
+    FileUtils.mkdir_p(File.dirname(@state_path))
+    AtomicWrite.write(@state_path, JSON.generate(state), renamer: @renamer)
+    state
+  end
+
+  def read_state
+    return nil unless File.file?(@state_path)
+
+    JSON.parse(File.read(@state_path))
+  rescue JSON::ParserError
+    nil
+  end
+
+  def load_thresholds
+    config = File.file?(@config_path) ? (YAML.safe_load(File.read(@config_path)) || {}) : {}
+    meter = config["meter"].is_a?(Hash) ? config["meter"] : {}
+    [
+      meter.fetch("reduce_at", DEFAULT_REDUCE_AT),
+      meter.fetch("stop_at", DEFAULT_STOP_AT),
+      meter.fetch("weekly_stop_at", DEFAULT_WEEKLY_STOP_AT),
+    ]
+  end
+
+  class << self
+    # Writes the LaunchAgent plist under an injectable home; never loads it
+    # with launchctl (scripts/meter-watch --install-timer calls this and
+    # nothing else). RunAtLoad primes the first tick; StartInterval repeats
+    # it every 20 minutes.
+    def install_timer(home:, script_path:, ruby: RbConfig.ruby, interval: TICK_SECONDS)
+      agents_dir = File.join(home, "Library", "LaunchAgents")
+      FileUtils.mkdir_p(agents_dir)
+      plist_path = File.join(agents_dir, "com.plastic.meter-watch.plist")
+      File.write(plist_path, plist(script_path, home, ruby, interval))
+      plist_path
+    end
+
+    private
+
+    def plist(script_path, home, ruby, interval)
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+          <key>Label</key>
+          <string>com.plastic.meter-watch</string>
+          <key>ProgramArguments</key>
+          <array>
+            <string>#{ruby}</string>
+            <string>#{script_path}</string>
+            <string>--home</string>
+            <string>#{home}</string>
+          </array>
+          <key>StartInterval</key>
+          <integer>#{interval}</integer>
+          <key>RunAtLoad</key>
+          <true/>
+        </dict>
+        </plist>
+      XML
+    end
+  end
+end

package/scripts/lib/node_packet.rb

@@ -425,7 +425,15 @@ module NodePacket
     verify.split("\n").map(&:strip).reject(&:empty?).join("; ")
   end
 
-  def test_command_block(intent_dir:, project_reader: method(:default_project_reader))
+  # `files` (intent 355, n4, D5): a node's own declared `*_test.rb` files
+  # name the only test command the executor needs - `bin/test --only <those
+  # files>` - so it never has to invent one or fall back to the project's
+  # generic `release.verify`. A node that declares no test files (a docs-only
+  # node, say) still falls back to `project_reader` exactly as before.
+  def test_command_block(intent_dir:, files: [], project_reader: method(:default_project_reader))
+    named = Array(files).select { |f| f.to_s.end_with?("_test.rb") }
+    return "test command: ruby bin/test --only #{named.join(' ')}" if named.any?
+
     cmd = project_reader.call(intent_dir)
     cmd ? "test command: #{cmd}" : "test command: none recorded in the project record"
   end
@@ -435,14 +443,26 @@ module NodePacket
   # carries no lease. `worktree_block` already renders its own copy when the
   # worktree is unprovisioned; the two conditions often fire together, so a
   # directive already present is never repeated.
+  #
+  # `call_cap` (intent 355, n2, D2): one sentence naming this attempt's tool
+  # call cap and the return it hits at, so the executor learns the number
+  # from the packet it starts with, never from a denied call mid-edit
+  # (matrix 2.4). nil (a caller that names no cap) renders nothing here.
   def where_to_work_block(intent_dir:, worktree_reader: Arm.method(:worktree_block),
-                           project_reader: method(:default_project_reader), lease_missing: false)
+                           project_reader: method(:default_project_reader), lease_missing: false, call_cap: nil,
+                           files: [])
     wt = worktree_block(intent_dir: intent_dir, worktree_reader: worktree_reader)
-    parts = [wt, test_command_block(intent_dir: intent_dir, project_reader: project_reader)]
+    parts = [wt, test_command_block(intent_dir: intent_dir, files: files, project_reader: project_reader)]
     parts << STOP_DIRECTIVE if lease_missing && !wt.include?(STOP_DIRECTIVE)
+    parts << call_cap_sentence(call_cap) if call_cap
     parts.join("\n")
   end
 
+  def call_cap_sentence(call_cap)
+    "call budget: this attempt may make at most #{call_cap} tool calls; past that a hook denies the " \
+      "next one, so commit what is green and return failed_verification reason=call_budget."
+  end
+
   # --- section and list parsing (shared) -------------------------------------
 
   # The body of the FIRST heading, at exactly `level` `#` characters, whose
@@ -786,7 +806,8 @@ module NodePacket
   def build(intent_dir:, node:, budget_tokens: nil, hop_tokens: DEFAULT_HOP_TOKENS,
             holder: nil, expires: nil, model: nil, attempt: nil, out: nil, force: false,
             renamer: File.method(:rename), git_runner: DEFAULT_GIT_RUNNER,
-            worktree_reader: Arm.method(:worktree_block), project_reader: method(:default_project_reader))
+            worktree_reader: Arm.method(:worktree_block), project_reader: method(:default_project_reader),
+            call_cap: nil)
     intent_dir = File.expand_path(intent_dir)
 
     nb = node_block(intent_dir: intent_dir, node: node)
@@ -826,7 +847,8 @@ module NodePacket
     # ledger data (spec D3's self-cancellation risk).
     missing_lease = lease_missing?(node: node, holder: holder, expires: expires, model: model, entries: entries)
     where_text = where_to_work_block(intent_dir: intent_dir, worktree_reader: worktree_reader,
-                                      project_reader: project_reader, lease_missing: missing_lease)
+                                      project_reader: project_reader, lease_missing: missing_lease,
+                                      call_cap: call_cap, files: nb[:files])
 
     state = {
       node_text: nb[:text], ledger_text: ledger_text, intent_text: record[:intent],

package/scripts/lib/runner_dispatch.rb

@@ -45,6 +45,22 @@ 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 `plastic-advisor`, which
+  # stays a deliberate, never-auto-dispatched consultation agent.
+  SPAWN_AGENT = "plastic-executor"
+
+  # matrix 6.1/6.2: one spawn block per dispatched node - agent, the model
+  # RunnerPolicy.model_for resolved, the packet path, the one test command
+  # (NodePacket.test_command_block, n4), and the call cap (n2) - fenced so a
+  # session pastes it straight into the Agent tool (327 D42: the runner
+  # itself never spawns).
+  def spawn_block(model:, packet:, test_command:, call_cap:, agent: SPAWN_AGENT)
+    lines = ["agent: #{agent}", "model: #{model}", "packet: #{packet}", test_command,
+             NodePacket.call_cap_sentence(call_cap)]
+    (["```"] + lines + ["```"]).join("\n")
+  end
+
   # dispatch(context, limit:) -> a result hash. Always carries :ok, :reason,
   # :errors, :rearm_command, :dispatched, :stop, :parked, :status, :blockers,
   # :plan - fields that do not apply to a given outcome stay nil/empty rather
@@ -195,6 +211,7 @@ module RunnerDispatch
     holder = context.session
     model = RunnerPolicy.model_for(kind, config: config)
     expires = RunnerPolicy.lease_expires(kind, now: now)
+    calls_cap = RunnerPolicy.call_cap(kind, config: config)
 
     # Row 10.16/M13: recorded BEFORE provisioning - a worktree this dispatch
     # finds already on disk (kept there by a prior failed_verification
@@ -223,7 +240,7 @@ module RunnerDispatch
     # default (row 10.9).
     build_result = packet_builder.call(intent_dir: intent_dir, node: node, holder: holder, expires: expires,
                                         model: model, force: true, worktree_reader: node_reader,
-                                        budget_tokens: node_declared_budget(intent_dir, node))
+                                        budget_tokens: node_declared_budget(intent_dir, node), call_cap: calls_cap)
     unless build_result[:ok]
       # M6: a failed packet build never leaves an orphan worktree behind, and
       # its errors travel back up so the step's report can name the node and
@@ -236,7 +253,7 @@ module RunnerDispatch
     precondition = lambda do |c|
       ReadySet.ready?(content: c, subject: node, graph: { edges: edges }, nodes: nodes_decl, caps: caps)[:ready]
     end
-    fields = { holder: holder, expires: expires, packet: build_result[:sha], model: model }
+    fields = { holder: holder, expires: expires, packet: build_result[:sha], model: model, calls: calls_cap }
 
     result = begin
       ledger.append_transition(savepoint_path, subject: node, state: "running", fields: fields, now: now,
@@ -254,10 +271,13 @@ module RunnerDispatch
       return { ok: false }
     end
 
+    test_command = NodePacket.test_command_block(intent_dir: intent_dir, files: (nodes_decl[node] || {})[:files])
+    spawn = spawn_block(model: model, packet: build_result[:path], test_command: test_command, call_cap: calls_cap)
+
     {
       ok: true,
       entry: { node: node, kind: kind.to_s, role: role_for(kind), model: model, worktree: provisioned[:path],
-                packet: build_result[:path] },
+                packet: build_result[:path], spawn: spawn },
     }
   end
 
@@ -461,7 +481,10 @@ module RunnerDispatch
   # Row 5.22/5.23/5.24: one machine-readable (YAML) document naming, per
   # dispatched node, the packet path, the model, the worktree, the kind and
   # the role, plus the return contract ONCE at the top level - never inside
-  # any one node's packet.
+  # any one node's packet. Row 6.4: "spawn" carries the same, already fully
+  # rendered spawn block for each dispatched node in order, so any reader of
+  # this data (YAML today, JSON if it is ever re-serialized) finds it under
+  # `spawn` rather than re-deriving it from the other fields.
   def render_plan(dispatched)
     return nil if dispatched.empty?
 
@@ -470,7 +493,8 @@ module RunnerDispatch
       "dispatch" => dispatched.map do |d|
         { "node" => d[:node], "kind" => d[:kind], "role" => d[:role], "model" => d[:model],
           "worktree" => d[:worktree], "packet" => d[:packet] }
-      end
+      end,
+      "spawn" => dispatched.map { |d| d[:spawn] }
     )
   end
   private_class_method :render_plan

package/scripts/lib/runner_policy.rb

@@ -139,4 +139,35 @@ module RunnerPolicy
   def lease_expires(kind, now: Time.now)
     (now + (lease_minutes(kind) * 60)).utc.strftime("%Y-%m-%dT%H:%M:%SZ")
   end
+
+  # --- call budget (intent 355, n2) -------------------------------------------
+  #
+  # D2: a cap on tool calls per attempt, enforced by a PreToolUse hook that
+  # counts tool calls in the session transcript. Shipped per kind (matrix
+  # 2.1); `decision` carries one too even though it is never dispatched
+  # (327 D12 leaves it out of every lease table for the same reason), so
+  # `call_cap` never has to special-case an unknown kind here any more than
+  # `retry_cap` does.
+  CALL_CAP_TABLE = { "work" => 60, "verify" => 40, "research" => 40, "decision" => 10 }.freeze
+
+  # matrix 5.17's own fallback rule, one call: an unknown or nil kind reads
+  # `work`'s cap, never a fourth, undeclared number.
+  def call_cap(kind, config: {})
+    override = call_caps_section(config)[kind.to_s]
+    present?(override) ? override.to_i : CALL_CAP_TABLE.fetch(kind.to_s, CALL_CAP_TABLE["work"])
+  end
+
+  # matrix 2.2: `runner.call_caps.<kind>` in the project config overrides the
+  # shipped cap, the same nested-Hash shape AgentModels.models_section reads
+  # `agents.models` from - one more caller of the pattern, not a new one.
+  def call_caps_section(config)
+    return {} unless config.is_a?(Hash)
+
+    runner = config["runner"]
+    return {} unless runner.is_a?(Hash)
+
+    section = runner["call_caps"]
+    section.is_a?(Hash) ? section : {}
+  end
+  private_class_method :call_caps_section
 end

package/scripts/lib/runner_proposals.rb

@@ -46,6 +46,8 @@ module RunnerProposals
     "research" => "node-research.md",
   }.freeze
 
+  REVIEW_FIX_CAP = 2
+
   # accept(context, proposer:, proposed_nodes:, proposed_edges:, now:,
   # validator:, templates_dir:, renamer:) -> {ok:, minted:, validator:,
   # errors:}. `proposer` names the node whose return carried these proposals
@@ -129,6 +131,14 @@ module RunnerProposals
       edge_specs << { from: from, to: to }
     end
 
+    trial_nodes = loaded[:nodes].merge(node_specs.to_h { |s| [s[:id], { kind: s[:kind] }] })
+    existing_fixes = review_fix_count(loaded[:edges], loaded[:nodes])
+    trial_fixes = review_fix_count(trial_edges, trial_nodes)
+    if trial_fixes > [existing_fixes, REVIEW_FIX_CAP].max
+      return refuse(intent_dir, proposer,
+                     "proposal refused (review_fix_cap): would make #{trial_fixes} review fixes, the cap is #{REVIEW_FIX_CAP}", now)
+    end
+
     node_specs.each { |s| scaffold_node_file(intent_dir, s) }
     if node_specs.any? || edge_specs.any?
       append_to_graph(graph_path, node_specs: node_specs, edge_specs: edge_specs, renamer: renamer)
@@ -141,6 +151,17 @@ module RunnerProposals
     { ok: true, minted: node_specs.map { |s| s[:id] }, validator: safe_validate(validator, intent_dir), errors: [] }
   end
 
+  # --- review fixes (355 D4) -------------------------------------------------
+
+  # review_fix_count(edges, nodes) -> how many work nodes GraphEdges.review_fixes
+  # finds, a node's kind read from its declaration and, when that is missing,
+  # from its id's NodeFile::KIND_PREFIX (343 D6).
+  def review_fix_count(edges, nodes)
+    ids = (edges.keys + edges.values.flatten).uniq
+    kinds = ids.to_h { |id| [id, (nodes[id] || {})[:kind] || NodeFile::KIND_PREFIX.key(id.to_s[/\A[a-z]+/])] }
+    GraphEdges.review_fixes(edges, kinds).length
+  end
+
   # --- node scaffolding --------------------------------------------------
 
   # A template's own placeholder id ("n1", "v1", ...) is replaced only as a