silas 0.1.6 → 0.2.0

data/lib/silas/eval/scripted_engine.rb

@@ -4,8 +4,6 @@ module Silas
     # eval script the MODEL's decisions while the REAL Ledger runs the REAL tools —
     # so assertions see a genuine transcript.
     class ScriptedEngine < Silas::Engines::Base
-      def self.loop_ownership = :framework
-
       attr_reader :calls
 
       def initialize(steps)

data/lib/silas/inbox/delta_broadcaster.rb

@@ -0,0 +1,38 @@
+module Silas
+  module Inbox
+    # Streams accumulated step text into the live trace as it arrives.
+    #
+    # Synchronous on purpose: broadcast_update_to, not _later — the row
+    # broadcasts ride ActiveJob because they are rare; a delta batch every
+    # ~100ms per running turn would swamp the queue. The push happens on the
+    # worker thread mid-model-call, so it is wrapped: a cable/render failure
+    # can NEVER re-raise into the durable loop.
+    #
+    # Deltas are decoration. The authoritative after_commit row render replaces
+    # the whole step partial (dom_id target) and supersedes anything streamed
+    # into the inner text container.
+    module DeltaBroadcaster
+      EVENT = "silas.delta".freeze
+
+      class << self
+        def subscribe!
+          @subscription ||= ActiveSupport::Notifications.subscribe(EVENT) do |*args|
+            broadcast(args.last)
+          end
+        end
+
+        def broadcast(payload)
+          return unless Silas::Inbox.streaming?
+
+          Turbo::StreamsChannel.broadcast_update_to(
+            Silas::Inbox.stream_name(payload[:session_id]),
+            target: "silas-step-#{payload[:step_id]}-text",
+            html: ERB::Util.html_escape(payload[:text]) # plain text; the row render owns formatting
+          )
+        rescue StandardError => e
+          Rails.logger&.warn("[silas.inbox] delta broadcast failed: #{e.class}: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/silas/instructions.rb

@@ -17,7 +17,7 @@ module Silas
     end
 
     def render(turn)
-      [ base_instructions(turn), skill_index_block(turn.session), loaded_skills_block(turn.session) ]
+      [ base_instructions(turn), memory_block(turn.session), skill_index_block(turn.session), loaded_skills_block(turn.session) ]
         .compact.join("\n\n")
     end
 
@@ -31,6 +31,18 @@ module Silas
       ERB.new(path.read).result_with_hash(session: turn.session, agent_name: turn.session.agent_name)
     end
 
+    # Recent memories surface into the snapshot (bounded; recall digs deeper).
+    def memory_block(session)
+      return nil unless Silas.memory_enabled?
+
+      memories = Silas::Memory.recall(agent_name: session.agent_name,
+                                      limit: Silas.config.memory_injection_limit)
+      return nil if memories.empty?
+
+      "## Memory (most recent — use the recall tool for more)\n\n" +
+        memories.map { |m| "- #{m.to_line}" }.join("\n")
+    end
+
     # Advertise skill descriptions (eve's routing hint); bodies load on demand.
     def skill_index_block(session)
       advertised = Silas.skills.reject { |s| session.loaded_skills.include?(s.name) }

data/lib/silas/ledger.rb

@@ -20,10 +20,16 @@ module Silas
     GUARD_KEY = :silas_ledger_transaction
 
     class << self
-      # True while a ledger transaction is open on this thread. A continuation
-      # checkpoint inside would raise Interrupt and roll back committed-looking
-      # progress (spike finding #5) — AgentLoopJob asserts against this.
-      def in_transaction? = Thread.current[GUARD_KEY] == true
+      # True while a ledger transaction is open in this execution context. A
+      # continuation checkpoint inside would raise Interrupt and roll back
+      # committed-looking progress (spike finding #5) — AgentLoopJob asserts
+      # against this. Stored in IsolatedExecutionState (not Thread.current[],
+      # which is fiber-local) so the guard follows the app's configured
+      # isolation level, exactly like Silas.current_scope — under the default
+      # :thread isolation it survives into internally-created fibers
+      # (enumerators, streaming bodies) where a fiber-local flag would
+      # silently vanish.
+      def in_transaction? = ActiveSupport::IsolatedExecutionState[GUARD_KEY] == true
 
       def assert_no_checkpoint!
         return unless in_transaction?
@@ -50,9 +56,9 @@ module Silas
       end
 
       # Drive a SINGLE freshly-created invocation to a terminal state — the
-      # :agent_sdk MCP endpoint creates one invocation per tools/call and needs
-      # exactly the same exactly-once/effect-mode machinery as settle!. Returns
-      # :done or :parked; the invocation carries its .result.
+      # hosted MCP endpoint (Mcp::Handler) creates one invocation per tools/call
+      # and needs exactly the same exactly-once/effect-mode machinery as
+      # settle!. Returns :done or :parked; the invocation carries its .result.
       def execute_invocation!(invocation, resolver:)
         settle_invocation!(invocation, resolver)
       end
@@ -157,12 +163,18 @@ module Silas
         end
       end
 
+      # :once is scoped to tool name AND arguments. Name-only matching was a
+      # footgun: approving a £5 refund would silently auto-approve a £5,000
+      # refund later in the same session. Identical repeat calls still skip
+      # re-approval; anything else re-parks. Graded gates (thresholds, ranges)
+      # belong in an approval lambda, not :once. (Hash#== is order-independent,
+      # so jsonb key order can't produce false negatives.)
       def previously_approved?(invocation)
         ToolInvocation.joins(:turn)
                       .where(silas_turns: { session_id: invocation.turn.session_id },
                              tool_name: invocation.tool_name, approval_state: "approved")
                       .where.not(id: invocation.id)
-                      .exists?
+                      .any? { |prior| prior.arguments == invocation.arguments }
       end
 
       # Compare-and-swap claim: only one racing execution wins.
@@ -173,11 +185,15 @@ module Silas
         claimed
       end
 
+      # Save/restore, not set/clear: a nested guarded_transaction must not
+      # clobber the outer guard on exit (the old `ensure ... = false` opened a
+      # checkpoint-guard hole for the remainder of the outer transaction).
       def guarded_transaction
-        Thread.current[GUARD_KEY] = true
+        previous = ActiveSupport::IsolatedExecutionState[GUARD_KEY]
+        ActiveSupport::IsolatedExecutionState[GUARD_KEY] = true
         ApplicationRecord.transaction { yield }
       ensure
-        Thread.current[GUARD_KEY] = false
+        ActiveSupport::IsolatedExecutionState[GUARD_KEY] = previous
       end
 
       def wrap_result(result)

data/lib/silas/mcp/handler.rb

@@ -4,9 +4,9 @@ require "securerandom"
 module Silas
   module Mcp
     # JSON-RPC handler for the hosted MCP endpoint. tools/call runs the tool
-    # THROUGH the Ledger, so the :agent_sdk path gets the same exactly-once and
-    # effect-mode semantics as :ruby_llm. Closes over one turn + its anchor step;
-    # authenticated by a per-turn bearer token in the URL query.
+    # THROUGH the Ledger, so a remote MCP caller gets the same exactly-once and
+    # effect-mode semantics as the in-process loop. Closes over one turn + its
+    # anchor step; authenticated by a bearer token in the URL query.
     class Handler
       TOOL_PREFIX = "mcp__silas__".freeze
 
@@ -50,8 +50,9 @@ module Silas
         invocation.reload
 
         if outcome == :parked
-          # v1 excludes approval-gated tools; if one slips through, fail loud.
-          { "isError" => true, "content" => [ text_content("approval-gated tools are not supported by :agent_sdk") ] }
+          # The hosted endpoint excludes approval-gated tools; if one slips
+          # through, fail loud rather than park a caller that can't wait.
+          { "isError" => true, "content" => [ text_content("approval-gated tools are not supported over the hosted MCP endpoint") ] }
         else
           { "content" => [ text_content(JSON.generate(invocation.result)) ] }
         end

data/lib/silas/mcp/server.rb

@@ -2,20 +2,20 @@ require "socket"
 
 module Silas
   module Mcp
-    # A minimal HTTP/1.1 server hosting the MCP Handler for the lifetime of one
-    # claude -p subprocess. Deliberately NOT Puma/Rack: the transport claude's
-    # MCP client needs (verified in the spike) is plain request/response JSON —
-    # one request per connection, application/json, no SSE — so a raw threaded
-    # TCPServer is fewer moving parts than embedding an app server in a worker.
+    # A minimal HTTP/1.1 server hosting the MCP Handler in-process. Deliberately
+    # NOT Puma/Rack: the transport MCP clients need (verified in the spike) is
+    # plain request/response JSON — one request per connection,
+    # application/json, no SSE — so a raw threaded TCPServer is fewer moving
+    # parts than embedding an app server in a worker.
     #
     # In-process: the Handler has direct access to the Ledger/models, so no
-    # cross-service call is needed and it works on any worker box.
+    # cross-service call is needed and it works on any worker box. This is the
+    # seam for the "mount your agent's tools as an MCP server" feature.
     class Server
       attr_reader :port
 
-      def self.start(turn:, step:, tools:, resolver:, host: Silas.config.agent_sdk_mcp_host)
-        token = SecureRandom.hex(16)
-        turn.update_columns(mcp_token: token)
+      def self.start(turn:, step:, tools:, resolver:, host: Silas.config.mcp_server_host)
+        token = SecureRandom.hex(16) # minted and compared in memory only
         handler = Handler.new(turn: turn, step: step, tools: tools, resolver: resolver, token: token)
         new(handler: handler, turn: turn, token: token, host: host).tap(&:boot)
       end

data/lib/silas/nested_runner.rb

@@ -10,8 +10,8 @@ module Silas
   module NestedRunner
     module_function
 
-    def run(session, input:)
-      scope = Silas.subagent_scope(session.agent_name)
+    def run(session, input:, scope: nil)
+      scope ||= Silas.subagent_scope(session.agent_name)
       turn = session.turns.create!(index: 0, input: input)
 
       Silas.with_agent_scope(scope) do

data/lib/silas/registry.rb

@@ -73,6 +73,11 @@ module Silas
       b["load_skill"] = Silas::Tools::LoadSkill if skills.any?
       b["delegate"] = Silas::Tools::Delegate if subagent_dirs.any?
       b["run_code"] = Silas::Tools::RunCode if Silas.sandbox_enabled?
+      if Silas.memory_enabled?
+        b["remember"] = Silas::Tools::Remember
+        b["recall"] = Silas::Tools::Recall
+      end
+      b["handoff"] = Silas::Tools::Handoff if named_agent_dirs.any?
       b
     end
 
@@ -125,7 +130,7 @@ module Silas
         end
 
         [ name, build_agent_scope(Pathname(dir), name, const_base: "Agents::#{name.camelize}",
-                                                       run_code: Silas.sandbox_enabled?) ]
+                                                       run_code: Silas.sandbox_enabled?, named: true) ]
       end
     end
 
@@ -167,7 +172,7 @@ module Silas
     # identity under const_base, skills, the load_skill builtin when skills
     # exist, run_code when asked, and the scope's own digest (the same
     # NondeterminismError guard root turns get).
-    def build_agent_scope(dir, name, const_base:, agent: nil, run_code: false)
+    def build_agent_scope(dir, name, const_base:, agent: nil, run_code: false, named: false)
       tools = Dir[dir.join("tools/*.rb")].sort.to_h do |file|
         tname = File.basename(file, ".rb")
         klass = "#{const_base}::Tools::#{tname.camelize}".constantize
@@ -180,6 +185,11 @@ module Silas
       builtins = {}
       builtins["load_skill"] = Silas::Tools::LoadSkill if skills.any?
       builtins["run_code"] = Silas::Tools::RunCode if run_code
+      if named && Silas.memory_enabled?
+        builtins["remember"] = Silas::Tools::Remember
+        builtins["recall"] = Silas::Tools::Recall
+      end
+      builtins["handoff"] = Silas::Tools::Handoff if named && named_agent_dirs.size > 1
       resolver = ->(n) { (tools[n] || builtins.fetch(n)).new }
       definitions = (tools.values + builtins.values).map(&:schema)
       digest = Digest::SHA256.hexdigest(JSON.generate(tools: definitions, skills: skills.map { |s| [ s.name, s.description ] }))

data/lib/silas/step_runner.rb

@@ -11,7 +11,7 @@ module Silas
       step = Step.find_or_create_by!(turn: turn, index: index)
 
       unless step.completed?
-        result = execute_model_call(turn, index)
+        result = execute_model_call(turn, index, step)
 
         # One transaction: the step's response, its terminal verdict, and the
         # pending ledger rows commit together — or none of them do.
@@ -48,7 +48,7 @@ module Silas
       end
     end
 
-    def execute_model_call(turn, index)
+    def execute_model_call(turn, index, step)
       assert_definitions_unchanged!(turn)
       engine = Silas.resolved_engine
       context = {
@@ -60,10 +60,25 @@ module Silas
         model: turn_model(turn),
         limits: { max_steps: Silas.agent.max_steps }
       }
-      if (hook = Silas.config.around_model_call)
-        hook.call(context) { engine.execute_step(context) }
-      else
-        engine.execute_step(context)
+
+      # Live deltas: the engine yields Events, the buffer coalesces them into
+      # "silas.delta" notifications. A replayed step never reaches this method
+      # (the completed? guard above), so replay emits nothing. The emitter is
+      # created HERE and closed over by the inner block, so around_model_call
+      # hooks keep their existing one-argument contract and can't swallow it.
+      buffer = DeltaBuffer.new(turn: turn, step: step)
+      emitter = ->(event) { buffer.append(event.payload[:text].to_s) if event.type == :text_delta }
+
+      begin
+        if (hook = Silas.config.around_model_call)
+          hook.call(context) { engine.execute_step(context, &emitter) }
+        else
+          engine.execute_step(context, &emitter)
+        end
+      ensure
+        # Tail flush BEFORE the step row commits — the authoritative
+        # after_commit render must never race a straggling delta batch.
+        buffer.finish
       end
     end
 

data/lib/silas/tool.rb

@@ -7,6 +7,11 @@ module Silas
   #     approval :always                          # :never | :once | :always | lambda
   #     transactional!                            # or at_most_once! (default) / idempotent!
   #
+  # :once approves ONE (tool, arguments) pair per session — an identical repeat
+  # call skips re-approval; different arguments park again. For graded gates
+  # (e.g. auto-approve under a threshold) use a lambda:
+  #   approval ->(session:, input:) { input[:amount] > 5000 ? :user_approval : :approved }
+  #
   #     def call(order_id:, amount:, note: nil)
   #       ...
   #     end

data/lib/silas/tools/handoff.rb

@@ -0,0 +1,68 @@
+module Silas
+  module Tools
+    # Staff-to-staff composition WITHOUT free-form agent chatter: file a brief
+    # that starts (or awaits) another named agent's session, linked to this one.
+    # at_most_once! — the handoff is one external effect; a crash parks it
+    # in-doubt instead of double-starting the colleague.
+    class Handoff < Tool
+      class << self
+        # Roster from DIRECTORY NAMES only — reading scopes here would recurse
+        # (description -> digest -> scope build -> description). Names alone
+        # keep the digest roster-sensitive without the cycle.
+        def description
+          names = Dir[Rails.root.join("app/agents/*")].select { |p| File.directory?(p) }
+                     .map { |p| File.basename(p) }.sort
+          "Hand a task to another staff agent as a self-contained brief (they share none of " \
+          "your context). Async by default; await: true waits for their answer. " \
+          "Staff: #{names.join(', ')}."
+        end
+      end
+
+      param :agent, :string, desc: "Which staff agent takes this."
+      param :brief, :string, desc: "Fully self-contained task brief."
+      param :await, :boolean, desc: "true = run now and return their answer; default fire-and-forget."
+
+      at_most_once!
+
+      MAX_CHAIN = 3
+
+      def call(agent:, brief:, await: nil)
+        target = agent.to_s
+        return { "error" => "unknown agent #{target.inspect}" } unless Silas.named_agent?(target)
+        return { "error" => "an agent cannot hand off to itself" } if target == session.agent_name
+
+        chain = ancestry(session)
+        if chain.include?(target)
+          return { "error" => "handoff cycle: #{[ *chain.reverse, session.agent_name, target ].join(' -> ')}" }
+        end
+        return { "error" => "handoff chain too deep (max #{MAX_CHAIN})" } if chain.size >= MAX_CHAIN
+
+        nested = Session.create!(agent_name: target, parent_session_id: session.id,
+                                 metadata: { "handoff_from" => session.agent_name })
+        if await
+          # Inline drive via NestedRunner (NOT AgentLoopJob.perform_now: a
+          # Continuable job's isolated steps re-enqueue and return early under
+          # production isolate_steps — the await would see a half-run turn).
+          turn = NestedRunner.run(nested, input: brief, scope: Silas.named_agent_scope!(target))
+          { "session_id" => nested.id, "status" => turn.status, "answer" => turn.answer_text.to_s }
+        else
+          turn = nested.continue(input: brief, enqueue: false)
+          AgentLoopJob.perform_later(turn.id)
+          { "session_id" => nested.id, "status" => "queued" }
+        end
+      end
+
+      private
+
+      def ancestry(session)
+        names = []
+        cursor = session
+        while cursor.parent_session_id && names.size <= MAX_CHAIN
+          cursor = Session.find_by(id: cursor.parent_session_id) or break
+          names << cursor.agent_name
+        end
+        names
+      end
+    end
+  end
+end

data/lib/silas/tools/recall.rb

@@ -0,0 +1,18 @@
+module Silas
+  module Tools
+    # Read-side of memory: on-demand subject lookup (the injected snapshot
+    # carries only the most recent few — this digs deeper).
+    class Recall < Tool
+      description "Look up saved memories about a subject (yours + app-shared). Use before " \
+                  "asking a human something the staff may already know."
+      param :subject, :string, desc: "Entity ref to look up, e.g. 'author:jane'."
+      idempotent!
+
+      def call(subject:)
+        memories = Memory.recall(agent_name: session.agent_name, subjects: [ subject ], limit: 20)
+                         .select { |m| m.subject == subject.to_s.strip.downcase }
+        { "subject" => subject, "memories" => memories.map(&:to_line) }
+      end
+    end
+  end
+end

data/lib/silas/tools/remember.rb

@@ -0,0 +1,32 @@
+module Silas
+  module Tools
+    # Built-in, advertised when memory is enabled and the table exists. Writes
+    # are APPROVAL-GATED by default (config.memory_approval = :always) — a
+    # memory card parks in the inbox before anything persists, eve's
+    # user-approved-memory pattern done Rails-style. transactional! — the
+    # memory row and the ledger row commit together, exactly once.
+    class Remember < Tool
+      description "Save a durable memory for future sessions. Use for stable preferences and " \
+                  "facts worth keeping (\"author:jane · report_format: prefers CSV\"), never for " \
+                  "transient task state. Same subject+attribute supersedes the old value."
+      param :subject, :string, desc: "Entity this is about, e.g. 'author:jane' or 'retailer:kdp'."
+      param :content, :string, desc: "The fact, one plain sentence."
+      param :attribute, :string, desc: "Optional slot name (enables supersession), e.g. 'report_format'."
+      param :shared, :boolean, desc: "true = visible to ALL agents (app scope); default private to this agent."
+
+      transactional!
+      approval ->(session:, input:) do
+        Silas.config.memory_approval == :never ? :approved : :user_approval
+      end
+
+      def call(subject:, content:, attribute: nil, shared: nil)
+        memory = Memory.remember!(
+          agent_name: session.agent_name, subject:, content:, attribute:,
+          scope: shared ? "app" : "agent",
+          turn: session.turns.order(:index).last
+        )
+        { "remembered" => memory.to_line, "scope" => memory.scope }
+      end
+    end
+  end
+end

data/lib/silas/version.rb

@@ -1,3 +1,3 @@
 module Silas
-  VERSION = "0.1.6"
+  VERSION = "0.2.0"
 end

data/lib/silas.rb

@@ -24,23 +24,23 @@ require "silas/connection"
 require "silas/connections"
 require "silas/inbox"
 require "silas/inbox/cost"
+require "silas/inbox/delta_broadcaster"
+require "silas/delta_buffer"
 require "silas/budget"
 require "silas/registry"
 require "silas/agent"
 require "silas/tools/load_skill"
-require "silas/engines/base"
-require "silas/agent_sdk/version_guard"
-require "silas/agent_sdk/stream_parser"
-require "silas/agent_sdk/cli"
+require "silas/tools/remember"
+require "silas/tools/recall"
+require "silas/tools/handoff"
 require "silas/mcp/handler"
 require "silas/mcp/server"
-require "silas/engines/agent_sdk"
+require "silas/engines/base"
 require "ruby_llm"
 require "silas/engines/ruby_llm"
 require "silas/message_builder"
 require "silas/instructions"
 require "silas/step_runner"
-require "silas/subprocess_runner"
 require "silas/eval" # after engines (ScriptedEngine < Engines::Base)
 require "silas/chat"
 
@@ -94,13 +94,16 @@ module Silas
 
     def reset_agent_memo! = (@agent = nil) # after Registry.install! swaps dirs
 
-    # The inference adapter instance. config.engine may be a symbol (:ruby_llm,
-    # :agent_sdk) or any object responding to #execute_step (specs, custom).
+    # The inference adapter instance. config.engine may be :ruby_llm or any
+    # object responding to #execute_step (specs, custom).
     def resolved_engine
       @resolved_engine ||=
         case config.engine
         when :ruby_llm then Engines::RubyLLM.new
-        when :agent_sdk then Engines::AgentSdk.new
+        when :agent_sdk
+          raise Error, "the :agent_sdk engine was removed in Silas 0.2 — the claude -p " \
+                       "subprocess integration is gone (its subscription-auth rationale was " \
+                       "unreachable). Use engine :ruby_llm, the production path."
         when Symbol then raise Error, "unknown engine #{config.engine.inspect}"
         else config.engine
         end
@@ -152,6 +155,14 @@ module Silas
 
     # Named-agent roster: { "name" => AgentScope }.
     def named_agent_scopes = config.named_agent_scopes&.call || {}
+
+    # Memory is on when configured AND the table exists (upgrade-safe: an app
+    # that hasn't run the 0.1.7 migration simply doesn't advertise the tools).
+    def memory_enabled?
+      config.memory && Memory.table_exists?
+    rescue ActiveRecord::NoDatabaseError, ActiveRecord::ConnectionNotEstablished
+      false
+    end
     def named_agent?(name) = named_agent_scopes.key?(name.to_s)
 
     def named_agent_scope!(name)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: silas
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniel St Paul
@@ -117,6 +117,7 @@ files:
 - app/controllers/silas/inbox/base_controller.rb
 - app/controllers/silas/inbox/invocations_controller.rb
 - app/controllers/silas/inbox/sessions_controller.rb
+- app/controllers/silas/inbox/turns_controller.rb
 - app/helpers/silas/inbox/trace_helper.rb
 - app/jobs/silas/agent_loop_job.rb
 - app/jobs/silas/channel_delivery_job.rb
@@ -126,6 +127,7 @@ files:
 - app/mailers/silas/channel_mailer.rb
 - app/models/concerns/silas/inbox/broadcastable.rb
 - app/models/silas/application_record.rb
+- app/models/silas/memory.rb
 - app/models/silas/session.rb
 - app/models/silas/step.rb
 - app/models/silas/tool_invocation.rb
@@ -150,6 +152,8 @@ files:
 - db/migrate/20260715000003_add_parent_session_to_silas_sessions.rb
 - db/migrate/20260716000001_add_budget_overrides_to_silas_turns.rb
 - db/migrate/20260716000002_add_cancel_requested_to_silas_turns.rb
+- db/migrate/20260721000001_create_silas_memories.rb
+- db/migrate/20260724000001_drop_agent_sdk_columns_from_silas_turns.rb
 - lib/generators/silas/install/install_generator.rb
 - lib/generators/silas/install/templates/agent.yml
 - lib/generators/silas/install/templates/bin_ci
@@ -165,17 +169,14 @@ files:
 - lib/silas.rb
 - lib/silas/agent.rb
 - lib/silas/agent_scope.rb
-- lib/silas/agent_sdk/cli.rb
-- lib/silas/agent_sdk/stream_parser.rb
-- lib/silas/agent_sdk/version_guard.rb
 - lib/silas/budget.rb
 - lib/silas/channel.rb
 - lib/silas/chat.rb
 - lib/silas/configuration.rb
 - lib/silas/connection.rb
 - lib/silas/connections.rb
+- lib/silas/delta_buffer.rb
 - lib/silas/engine.rb
-- lib/silas/engines/agent_sdk.rb
 - lib/silas/engines/base.rb
 - lib/silas/engines/ruby_llm.rb
 - lib/silas/errors.rb
@@ -190,6 +191,7 @@ files:
 - lib/silas/eval/transcript.rb
 - lib/silas/inbox.rb
 - lib/silas/inbox/cost.rb
+- lib/silas/inbox/delta_broadcaster.rb
 - lib/silas/instructions.rb
 - lib/silas/ledger.rb
 - lib/silas/mcp/client.rb
@@ -207,10 +209,12 @@ files:
 - lib/silas/skill.rb
 - lib/silas/slack.rb
 - lib/silas/step_runner.rb
-- lib/silas/subprocess_runner.rb
 - lib/silas/tool.rb
 - lib/silas/tools/delegate.rb
+- lib/silas/tools/handoff.rb
 - lib/silas/tools/load_skill.rb
+- lib/silas/tools/recall.rb
+- lib/silas/tools/remember.rb
 - lib/silas/tools/run_code.rb
 - lib/silas/version.rb
 - lib/tasks/silas_chat.rake

data/lib/silas/agent_sdk/cli.rb

@@ -1,59 +0,0 @@
-require "json"
-
-module Silas
-  module AgentSdk
-    # Builds the verified claude -p argv and manages the subprocess. --bare is
-    # the API-key-only auth guard (never subscription OAuth); alwaysLoad + a
-    # non-zero MCP_TIMEOUT are BOTH mandatory or the single-shot -p turn races
-    # ahead of the MCP handshake and never sees the tools (spike trap #1).
-    class Cli
-      def initialize(bin:, prompt:, system:, model:, mcp_url:, allowed:, resume_session_id: nil)
-        @bin = bin
-        @prompt = prompt
-        @system = system
-        @model = model
-        @mcp_url = mcp_url
-        @allowed = allowed
-        @resume_session_id = resume_session_id
-      end
-
-      # Spawns claude, yields each stdout line, returns the exit status integer.
-      def stream
-        @io = IO.popen(env, argv, err: %i[child out], pgroup: true)
-        @pid = @io.pid
-        @io.each_line { |line| yield line }
-        @io.close
-        $?.exitstatus
-      end
-
-      def terminate
-        return unless @pid
-
-        Process.kill("-TERM", @pid)
-        Process.kill("-KILL", @pid)
-      rescue Errno::ESRCH, Errno::EPERM
-        # already gone
-      end
-
-      def argv
-        args = [ @bin, "-p", @prompt,
-                 "--output-format", "stream-json", "--verbose", "--bare",
-                 "--mcp-config", mcp_config_json,
-                 "--allowedTools", @allowed.join(","),
-                 "--model", @model ]
-        args += [ "--append-system-prompt", @system ] if @system.present?
-        args += [ "--resume", @resume_session_id ] if @resume_session_id.present?
-        args
-      end
-
-      def mcp_config_json
-        JSON.generate("mcpServers" => { "silas" => { "type" => "http", "url" => @mcp_url, "alwaysLoad" => true } })
-      end
-
-      def env
-        { "ANTHROPIC_API_KEY" => ENV["ANTHROPIC_API_KEY"],
-          "MCP_TIMEOUT" => Silas.config.agent_sdk_mcp_timeout_ms.to_s }
-      end
-    end
-  end
-end