pikuri-core 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9d64fe3a6b311841de49b193f6caa92cdb2ba0e627ef0195c73824d803fcafa
-  data.tar.gz: fa1112813faf7c4d6d162d467b4977c7b800bc647d35c0fe6fec79a1f30e6112
+  metadata.gz: f26e9b56204d1fbbaf64390e643a26c4183b3c21d45e3dcc43984c677a09f400
+  data.tar.gz: e657171d9440ef19a53ae5ad9335c62ff34ea8db62c9753ce79352f699122f06
 SHA512:
-  metadata.gz: f9b5618853d0501a417fbcfd021e1dd65fe45fef42331d9f8b4f1c8ab273a91437f433b7065512b46340d98670e53127cb49a5149eb7078750bd99a0e6ad22fa
-  data.tar.gz: a9ce6040b23bcd4a2eb4f11bc10c50cd64ad8fdba685e2eba51f9181a3f3503617adb230b0601257e3f0ec3122c14d1a12b5091ab03b7612f906d72c54938189
+  metadata.gz: 4f53aef4566f6218750c58b0cac4d1015d9ae2d2a1d464481ff4eabae3d42eb560559517a105ccd6fb2128e0b8e1b9393fdea257757dd6c85af0dc7a47683ed3
+  data.tar.gz: ba4adbf32911a499111eaf26057622e94fa27511aaefb5f9fb705ac3471a20d860536d1717e6933ec3e2b55af152fbfb8b479f99e11e44ea9ad907dd1c666a66

data/README.md

@@ -65,3 +65,13 @@ agent.run_loop(user_message: 'What is 17 * 23?')
 
 See `bin/pikuri-chat` for a worked example with REPL, signal
 handling, and cancellation.
+
+## Further reading
+
+- **Narrative walkthrough:** [chapter 1 of the pikuri guide](../docs/guide/01-chat.md)
+  — install llama.cpp, start the server, run `pikuri-chat`, the
+  agentic loop, the four bundled tools, and search-provider
+  privacy postures.
+- **API reference:** browse the YARD docs at
+  <https://rubydoc.info/gems/pikuri-core> (once published), or run
+  `bundle exec yard` in this directory for a local copy.

data/lib/pikuri/agent/chat_transport.rb

@@ -8,11 +8,12 @@ module Pikuri
     #
     # Bundling them is structural protection against a recurring bug
     # class — every forwarding site (the synthesizer rescue in
-    # {Agent#run_loop}, {Tool::SubAgent} spawning a sub-agent) used to
-    # pass the three individually, and dropping one routed the spawned
-    # chat to a different server or raised +RubyLLM::ModelNotFoundError+
-    # on the unknown model id. With a single value object the call site
-    # can't silently miss a field.
+    # {Agent#run_loop}, the +agent+ tool from +pikuri-subagents+
+    # spawning a sub-agent) used to pass the three individually, and
+    # dropping one routed the spawned chat to a different server or
+    # raised +RubyLLM::ModelNotFoundError+ on the unknown model id.
+    # With a single value object the call site can't silently miss a
+    # field.
     #
     # Pure data carrier: no +RubyLLM+ references here, so the seam stays
     # in {Agent}, +bin/pikuri-chat+, and {Tool}.

data/lib/pikuri/agent/configurator.rb

@@ -5,8 +5,9 @@ module Pikuri
     # Build-time collector yielded into the +Pikuri::Agent.new+ block.
     # Hosts and {Extension} implementations call its methods to declare
     # additional tools, listeners, system-prompt snippets, +on_close+
-    # handlers, and extension instances; {Agent#initialize} drains the
-    # collected state into the agent's final wiring before returning.
+    # handlers, extension instances, and persona-flavored sub-agents;
+    # {Agent#initialize} drains the collected state into the agent's
+    # final wiring before returning.
     #
     # == Why this exists
     #
@@ -15,10 +16,27 @@ module Pikuri
     #
     #   Pikuri::Agent.new(transport: ..., system_prompt: ...) do |c|
     #     c.add_listener Pikuri::Agent::Listener::Terminal.new
-    #     c.add_tool     Pikuri::Tool::CALCULATOR
+    #     c.add_tool     Pikuri::Tool::WEB_SEARCH
+    #     c.add_tool     Pikuri::Tool::WEB_SCRAPE
+    #     c.add_tool     Pikuri::Tool::FETCH
     #     c.add_extension Pikuri::Skill::Extension.new(catalog: catalog)
     #   end
     #
+    # == Two tool pools: regular vs. sub-agent-only
+    #
+    # {#add_tool} registers a tool the parent agent can call: it lands
+    # in {#tools} and gets handed to ruby_llm via +chat.with_tool+.
+    # {#add_sub_agent_tool} registers a tool the parent *cannot* call
+    # — it lands in {#sub_agent_tools} and is never sent to ruby_llm
+    # for the parent, but is visible to {Pikuri::SubAgent::Extension}'s
+    # persona-tool-name resolution. The use case is the lethal-trifecta
+    # defense in {Pikuri::Code::Bash::Sandbox} terms: keep network tools
+    # (+web_search+ / +web_scrape+ / +fetch+) off the parent so a prompt-
+    # injected file read cannot egress through the parent's own tools,
+    # while still letting the +researcher+ persona reach them via the
+    # +agent+ delegation tool. See SECURITY.md §"Defense: capability
+    # boundaries via sub-agents".
+    #
     # Extensions implement their +configure(c)+ hook against the same
     # type, so the call sites for "block users add stuff" and
     # "extensions add stuff" share one API.
@@ -44,9 +62,9 @@ module Pikuri
       #   available for diagnostics.
       attr_reader :system_prompt_base
 
-      # @return [String] this agent's identifier; empty for the main
-      #   agent, hierarchical (+"sub_agent 0_1"+) for sub-agents.
-      attr_reader :name
+      # @return [String] this agent's unique identifier; empty for the
+      #   main agent, persona-rooted (e.g. +"researcher 0"+) for sub-agents.
+      attr_reader :id
 
       # @return [Boolean] +true+ when the agent opted into chunk-level
       #   streaming.
@@ -68,9 +86,18 @@ module Pikuri
       attr_reader :interloper
 
       # @return [Array<Tool>] tools added via {#add_tool}, in
-      #   declaration order. Drained by {Agent#initialize}.
+      #   declaration order. Drained by {Agent#initialize} and
+      #   registered with ruby_llm so the parent LLM can call them.
       attr_reader :tools
 
+      # @return [Array<Tool>] tools added via {#add_sub_agent_tool},
+      #   in declaration order. Drained by {Agent#initialize} but
+      #   *not* registered with ruby_llm — invisible to the parent
+      #   LLM, available only to sub-agents through
+      #   {Pikuri::SubAgent::Extension}'s persona-tool-name
+      #   resolution. See the class header.
+      attr_reader :sub_agent_tools
+
       # @return [Array<Listener::Base>] listeners added via
       #   {#add_listener}, in declaration order. Drained by
       #   {Agent#initialize}.
@@ -93,38 +120,25 @@ module Pikuri
       #   wiring is complete.
       attr_reader :extensions
 
-      # @return [SubAgentRequest, nil] set when the block called
-      #   {#allow_sub_agent}; +nil+ otherwise. The Agent ctor uses
-      #   this to decide whether to create a {Tool::SubAgent}
-      #   instance after the chat is wired (so the SubAgent tool's
-      #   parent.tools snapshot doesn't include itself —
-      #   recursion guard).
-      attr_reader :sub_agent_request
-
-      # Record holding the +max_steps+ value the host passed to
-      # {#allow_sub_agent}. The Agent ctor consumes one of these
-      # records to build a {Tool::SubAgent} keyed to that step
-      # budget.
-      SubAgentRequest = Data.define(:max_steps)
-
       # @param transport [Agent::ChatTransport]
       # @param system_prompt_base [String]
-      # @param name [String]
+      # @param id [String]
       # @param streaming [Boolean]
       # @param step_limit [Control::StepLimit, nil]
       # @param cancellable [Control::Cancellable, nil]
       # @param interloper [Control::Interloper, nil]
-      def initialize(transport:, system_prompt_base:, name:, streaming:,
+      def initialize(transport:, system_prompt_base:, id:, streaming:,
                      step_limit:, cancellable:, interloper:)
         @transport = transport
         @system_prompt_base = system_prompt_base
-        @name = name
+        @id = id
         @streaming = streaming
         @step_limit = step_limit
         @cancellable = cancellable
         @interloper = interloper
 
         @tools = []
+        @sub_agent_tools = []
         @listeners = []
         @system_prompt_additions = []
         @on_close_handlers = []
@@ -142,8 +156,6 @@ module Pikuri
 
       # Append several tools at once. Equivalent to calling {#add_tool}
       # for each element of +tools+; declaration order is preserved.
-      # Sole intended caller today is {Tool::SubAgent}, which seeds a
-      # sub-agent's Configurator from the parent's tool snapshot.
       #
       # @param tools [Enumerable<Tool>]
       # @return [void]
@@ -152,6 +164,18 @@ module Pikuri
         nil
       end
 
+      # Append a tool to the sub-agent-only pool. The parent LLM
+      # never sees it; only sub-agents whose persona +tool_names+
+      # include the tool's +name+ get it in their toolset. See the
+      # class header for the trifecta-defense rationale.
+      #
+      # @param tool [Tool]
+      # @return [void]
+      def add_sub_agent_tool(tool)
+        @sub_agent_tools << tool
+        nil
+      end
+
       # Append a listener to the agent's listener list.
       #
       # @param listener [Listener::Base]
@@ -163,9 +187,6 @@ module Pikuri
 
       # Append several listeners at once. Accepts any enumerable
       # (Array, {ListenerList}, …); declaration order is preserved.
-      # Sole intended caller today is {Tool::SubAgent}, which seeds a
-      # sub-agent's Configurator from the parent's listener list (run
-      # through {ListenerList#for_sub_agent}).
       #
       # @param listeners [Enumerable<Listener::Base>]
       # @return [void]
@@ -207,26 +228,6 @@ module Pikuri
         nil
       end
 
-      # Retain a list of already-configured extensions for the
-      # bind sweep without re-running +configure+. Sole intended
-      # caller is {Tool::SubAgent}, which seeds a sub-agent's
-      # Configurator from the parent's extension list — the parent
-      # already drove +configure+ and its system-prompt snippets /
-      # static tools are inherited by the sub-agent verbatim
-      # through {#add_tools} + {#add_listeners} + the augmented
-      # +system_prompt+; re-running +configure+ on the sub-agent
-      # would double up those contributions. The +bind(sub_agent)+
-      # sweep in {Agent#initialize} still fires on each inherited
-      # extension so per-agent state (MCP's per-agent connect tool,
-      # for example) gets installed fresh on the sub-agent.
-      #
-      # @param extensions [Enumerable<Extension>]
-      # @return [void]
-      def inherit_extensions(extensions)
-        extensions.each { |ext| @extensions << ext }
-        nil
-      end
-
       # Register a handler called by {Agent#close}. Handlers fire in
       # LIFO order, each inside its own +rescue+ — same semantics as
       # +ensure+-block cleanup discipline.
@@ -239,32 +240,6 @@ module Pikuri
         @on_close_handlers << blk
         nil
       end
-
-      # Enable the +sub_agent+ tool on this agent. Records the
-      # +max_steps+ budget for sub-agent runs; the Agent ctor reads
-      # {#sub_agent_request} after the block returns and constructs
-      # the actual {Tool::SubAgent} so its snapshot of the parent's
-      # tool list doesn't include itself (recursion guard).
-      #
-      # Sub-agents inherit the parent's tool list (minus +sub_agent+
-      # itself), augmented system prompt, listeners (via
-      # +for_sub_agent+ per listener), controls (per the per-control
-      # rule), and the parent's extension list. Each inherited
-      # extension's +bind(sub_agent)+ fires during the sub-agent's
-      # construction — that's how MCP's per-agent connect tool ends
-      # up keyed to the sub-agent rather than the parent.
-      #
-      # @param max_steps [Integer] step budget for each sub-agent
-      #   run, passed to {Tool::SubAgent#initialize}.
-      # @raise [RuntimeError] if called more than once on the same
-      #   Configurator.
-      # @return [void]
-      def allow_sub_agent(max_steps: 10)
-        raise 'allow_sub_agent may only be called once per agent' if @sub_agent_request
-
-        @sub_agent_request = SubAgentRequest.new(max_steps: max_steps)
-        nil
-      end
     end
   end
 end

data/lib/pikuri/agent/control/cancellable.rb

@@ -40,13 +40,13 @@ module Pikuri
       #
       # == Sub-agent semantics
       #
-      # {#for_sub_agent} returns +self+ — the same instance is
-      # shared by reference across the parent, every sub-agent,
-      # and the synthesizer rescue. One {#cancel!} call stops the
-      # whole tree. This contrasts with {StepLimit}, which gives
-      # each agent its own counter (because step budgets are
-      # per-agent concerns) — cancellation is a global signal
-      # from the user, so it must propagate down.
+      # Cancellation is a global "stop the whole tree" signal —
+      # the +agent+ tool from +pikuri-subagents+ shares the
+      # parent's +Cancellable+ by reference when spawning a child,
+      # so one {#cancel!} call stops the parent, every running
+      # sub-agent, and the synthesizer rescue. The sharing rule
+      # lives at the spawn site (sub-agent code), not on this
+      # class.
       class Cancellable
         # Raised by {#check!} once {#cancel!} has been called.
         # Carries no fields; the cancellation reason ("the user
@@ -105,16 +105,6 @@ module Pikuri
           @cancelled = false
         end
 
-        # Sub-agent variant: the same instance, shared by
-        # reference, so a single {#cancel!} stops the parent,
-        # every running sub-agent, and the synthesizer rescue.
-        # See the class header for the rationale.
-        #
-        # @return [Cancellable] the receiver
-        def for_sub_agent(**)
-          self
-        end
-
         # @return [String] short label for {Agent#to_s}; reflects
         #   the current flag state so a startup banner or debug
         #   print can tell an armed token apart from one that has

data/lib/pikuri/agent/control/interloper.rb

@@ -70,16 +70,16 @@ module Pikuri
       #
       # == Sub-agent semantics
       #
-      # {#for_sub_agent} returns +nil+. Sub-agents are private to
-      # the parent agent; the host has no handle to them, so a
-      # child +Interloper+ would be unreachable. The sub-agent's
-      # {Agent#initialize} simply receives +interloper: nil+ from
-      # {Tool::SubAgent}, which is its default. The behavior
-      # contrasts with {Control::Cancellable}, which shares its
-      # instance by reference so the parent's signal propagates
-      # to children — cancellation is a global "stop the whole
-      # tree" event, whereas injection is a directed "talk to the
-      # main agent" event.
+      # Sub-agents are private to the parent agent; the host has
+      # no handle to them, so a child +Interloper+ would be
+      # unreachable. The +agent+ tool from +pikuri-subagents+
+      # therefore omits the kwarg when spawning a child, leaving
+      # the sub-agent's +interloper+ at its default +nil+. The
+      # behavior contrasts with {Control::Cancellable}, which is
+      # shared by reference so the parent's signal propagates to
+      # children — cancellation is a global "stop the whole tree"
+      # event, whereas injection is a directed "talk to the main
+      # agent" event.
       class Interloper
         def initialize
           @mutex = Mutex.new
@@ -143,17 +143,6 @@ module Pikuri
           end
         end
 
-        # Sub-agent variant: +nil+, signalling to {Agent} (and
-        # transitively to {Tool::SubAgent}) that no +Interloper+
-        # should be wired on a spawned sub-agent. See the class
-        # header for the "host has no handle to sub-agents"
-        # rationale.
-        #
-        # @return [nil]
-        def for_sub_agent(**)
-          nil
-        end
-
         # @return [String] short label for {Agent#to_s}; reflects
         #   the pending-count so a debug print or banner can tell
         #   an idle interloper apart from one with queued items

data/lib/pikuri/agent/control/step_limit.rb

@@ -69,20 +69,6 @@ module Pikuri
         #   can introspect it (and so tests can assert it)
         attr_reader :step
 
-        # Sub-agent variant: a fresh +StepLimit+ at the
-        # caller-supplied +max_steps:+, or — when the key is
-        # absent — at the receiver's own cap. The mutable counter
-        # is per-chat, so the parent's instance cannot govern a
-        # sub-agent's chat; every sub-agent needs its own.
-        #
-        # @param max_steps [Integer] positive step cap for the
-        #   sub-agent; defaults to the receiver's current cap
-        # @return [StepLimit]
-        # @raise [ArgumentError] if +max_steps+ is non-positive
-        def for_sub_agent(max_steps: @max)
-          self.class.new(max: max_steps)
-        end
-
         # @return [String] short config dump for {Agent#to_s}
         def to_s
           "StepLimit(max=#{@max})"

data/lib/pikuri/agent/extension.rb

@@ -57,22 +57,20 @@ module Pikuri
 
       # Called by {Agent#initialize} after the block returns and the
       # chat is fully wired, with the live {Agent} as the argument.
-      # Runs once per agent — on the parent during its construction,
-      # and once more on each sub-agent during the sub-agent's
-      # construction (same extension instance, multiple +bind+ calls
-      # — per-agent state lives in +bind+'s closures, not in
-      # extension instance state). The default is a no-op; override
-      # when you need to install *per-agent* state. Things you
-      # typically do here:
+      # Fires once per agent the extension was registered to via
+      # {Configurator#add_extension} — in the typical setup that's
+      # the parent agent only, since sub-agents do not inherit
+      # extensions. The default is a no-op; override when you need
+      # to install state keyed to the live agent object. Things
+      # you typically do here:
       #
-      # * register per-agent dynamic tools via
-      #   {Agent#internal_add_tool}
-      # * register per-agent +on_close+ handlers via
-      #   {Agent#on_close}
+      # * register dynamic tools via {Agent#internal_add_tool}
+      #   (used by {Pikuri::Mcp::Extension} for +mcp_connect+,
+      #   whose +execute+ closure needs the live agent so
+      #   activations register on the right chat)
+      # * register +on_close+ handlers via {Agent#on_close}
       # * stash an +@agent+ reference if the extension's tools need
-      #   to act on this specific agent later (e.g. when a tool
-      #   fires and wants to register more tools on its owning
-      #   chat)
+      #   to act on this specific agent later
       #
       # @param agent [Agent] the live agent, fully wired
       # @return [void]

data/lib/pikuri/agent/listener/token_log.rb

@@ -41,10 +41,10 @@ module Pikuri
       #
       #   msg #1: ctx=6.8k/32.0k  Δ+6.8k  ↑6.8k  ↓0.0k
       #
-      # When the owning {Agent} has a non-empty {Agent#name} (i.e.
-      # a sub-agent), the line is prefixed with +[name] +:
+      # When the owning {Agent} has a non-empty {Agent#id} (i.e. a
+      # sub-agent), the line is prefixed with +[id] +:
       #
-      #   [sub_agent 0] msg #1: ctx=4.2k  Δ+4.2k  ↑4.2k  ↓0.0k
+      #   [researcher 0] msg #1: ctx=4.2k  Δ+4.2k  ↑4.2k  ↓0.0k
       #
       # +ctx+ is the snapshot
       # (+input + cached + cache_creation + output+; see
@@ -89,16 +89,15 @@ module Pikuri
         # @return [Integer, nil]
         attr_accessor :context_window_cap
 
-        # @return [String] owning agent's identifier. Empty by
+        # @return [String] owning agent's id ({Agent#id}). Empty by
         #   default (main agent); set by {#for_sub_agent} from the
-        #   sub-agent's generated name so the log lines can be
-        #   prefixed with +[<name>] +. Read-only — for a
-        #   sub-agent's listener you get a fresh instance via
-        #   {#for_sub_agent}.
-        attr_reader :name
+        #   sub-agent's generated id so the log lines can be
+        #   prefixed with +[<id>] +. Read-only — for a sub-agent's
+        #   listener you get a fresh instance via {#for_sub_agent}.
+        attr_reader :id
 
         # The most recent log line, in the exact format written to
-        # {LOGGER} (including any +[<name>] + prefix). Empty until
+        # {LOGGER} (including any +[<id>] + prefix). Empty until
         # the first {Event::Tokens} has been processed. Hosts that
         # want to surface the current context-window snapshot in
         # their own UI (e.g. a TUI status footer) read this
@@ -113,12 +112,12 @@ module Pikuri
         # @return [String]
         attr_reader :status_line
 
-        # @param name [String] agent identifier prepended to each
-        #   log line as +[<name>] + when non-empty. Defaults to
-        #   +""+ for the main agent.
-        def initialize(name: '')
+        # @param id [String] owning agent's id, prepended to each
+        #   log line as +[<id>] + when non-empty. Defaults to +""+
+        #   for the main agent.
+        def initialize(id: '')
           super()
-          @name = name
+          @id = id
           @msg = 0
           @context_window_size = 0
           @context_window_cap = nil
@@ -128,17 +127,17 @@ module Pikuri
         # Sub-agent variant: a fresh +TokenLog+ with a zeroed
         # snapshot so the sub-agent's context-window readings
         # track its own +RubyLLM::Chat+ rather than continuing the
-        # parent's. Picks the sub-agent's +name:+ out of the
-        # forwarded params so its log lines carry the +[<name>] +
+        # parent's. Picks the sub-agent's +id:+ out of the
+        # forwarded params so its log lines carry the +[<id>] +
         # prefix; defaults to +""+ when absent. The cap is left
         # +nil+ here; the sub-agent's {Agent#initialize} emits a
         # fresh {Event::ContextCap} immediately after construction
         # and this listener picks it up off the stream.
         #
-        # @param name [String] sub-agent's identifier
+        # @param id [String] sub-agent's id
         # @return [TokenLog]
-        def for_sub_agent(name: '', **)
-          self.class.new(name: name)
+        def for_sub_agent(id: '', **)
+          self.class.new(id: id)
         end
 
         # @param event [Agent::Event]
@@ -184,7 +183,7 @@ module Pikuri
 
         def format_line(input, output, delta)
           sign = delta.negative? ? '-' : '+'
-          prefix = @name.empty? ? '' : "[#{@name}] "
+          prefix = @id.empty? ? '' : "[#{@id}] "
           "#{prefix}msg ##{@msg}: ctx=#{format_ctx}  Δ#{sign}#{format_k(delta.abs)}  ↑#{format_k(input)}  ↓#{format_k(output)}"
         end
 

data/lib/pikuri/agent/listener_list.rb

@@ -35,8 +35,9 @@ module Pikuri
 
       # Iterate over the wrapped listeners in registration order. The
       # method exists so a ListenerList can be passed directly to
-      # {Configurator#add_listeners} (used by {Tool::SubAgent} when
-      # seeding a sub-agent's Configurator from the parent's list).
+      # {Configurator#add_listeners} (used by the +agent+ tool from
+      # +pikuri-subagents+ when seeding a sub-agent's Configurator
+      # from the parent's list).
       #
       # @yield [listener]
       # @yieldparam listener [Listener::Base]
@@ -59,13 +60,14 @@ module Pikuri
       # change this class — see {Listener::Terminal#for_sub_agent}
       # (fresh padded instance) and
       # {Listener::TokenLog#for_sub_agent} (fresh, zeroed snapshot
-      # with the forwarded +name:+).
+      # with the forwarded +id:+).
       #
       # +params+ is a flat hash forwarded as kwargs to every
       # listener's hook; each listener picks the keys it cares about
       # and ignores the rest. The only key currently consumed by
-      # bundled listeners is +name:+ (used by {Listener::TokenLog}).
-      # Calling with no params is always valid.
+      # bundled listeners is +id:+ (used by {Listener::TokenLog} to
+      # prefix its log lines with the sub-agent's id). Calling with
+      # no params is always valid.
       #
       # @param params [Hash{Symbol => Object}]
       # @return [ListenerList]

data/lib/pikuri/agent/synthesizer.rb

@@ -45,7 +45,7 @@ module Pikuri
       # reasoning and answer flow through the same listener
       # surface the parent agent uses — terminal renders them
       # inline (padded under sub-agent), an in-memory recorder
-      # picks them up, a TokenLog tags them with the synth name.
+      # picks them up, a TokenLog tags them with the synth id.
       #
       # @param chat [RubyLLM::Chat] a *fresh* chat with no tools.
       #   The caller is responsible for constructing it with the
@@ -58,7 +58,7 @@ module Pikuri
       # @param listeners [Agent::ListenerList] listeners to wire
       #   the synth chat into. Typically the parent agent's list
       #   run through {ListenerList#for_sub_agent} with the
-      #   synth's +name:+ so any +TokenLog+ tags its lines with
+      #   synth's +id:+ so any +TokenLog+ tags its lines with
       #   the synth bracket and any +Terminal+ pads its output.
       # @param step_limit [Control::StepLimit, nil] defensive
       #   step budget. The synth has no tools so it should never