little_ghost 0.7.0 → 0.9.0

data/docs/guides/skills.md

@@ -107,9 +107,7 @@ LittleGhost.configure do |config|
 
   config.sandbox = {
     provider: :native,
-    files: {root: :read_write, skills: :read_only},
-    root_filesystem: :isolated,
-    network: :none
+    files: {root: :read_write, skills: :read_only}
   }
 end
 ```

data/docs/guides/tools.md

@@ -79,6 +79,8 @@ end
 Prefer `available_if` on an individual Tool when only that operation is
 conditional. Use a provider when the collection itself owns discovery,
 construction, or shared setup for an application or remote service.
+The [MCP guide](mcp.md) shows how a Model Context Protocol server provides a
+Toolset through the official Ruby client.
 
 LittleGhost does not enforce class names. A useful application convention is
 to end one model-callable operation with `Tool` and a provider of multiple

data/exe/little_ghost

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "little_ghost/cli"
+
+source_path = File.expand_path("..", __dir__)
+source_path = nil unless File.file?(File.join(source_path, "little_ghost.gemspec"))
+
+exit LittleGhost::CLI.new(ARGV, source_path:).run

data/lib/little_ghost/agent/context_management.rb

@@ -35,17 +35,6 @@ module LittleGhost
       DEFAULT_PRESERVE_RECENT_MESSAGES = 10 # :nodoc:
       ESTIMATED_CHARS_PER_TOKEN = 4 # :nodoc:
       OUTPUT_LIMIT_STOP_REASONS = %i[max_tokens limit_output_tokens limit_total_tokens limit_turns].freeze # :nodoc:
-      SUMMARIZATION_PROMPT = <<~PROMPT # :nodoc:
-        You are a conversation summarizer. Provide a concise summary of the conversation history.
-
-        Format requirements:
-        - Create a structured, concise summary in bullet-point format.
-        - Do not respond conversationally, address the user directly, or comment on tool availability.
-        - Preserve key topics, questions, significant tool executions and results, code or technical information, and key insights.
-        - Do not assume tool executions failed unless otherwise stated.
-        - Write the summary in the third person.
-      PROMPT
-
       def self.included(base) # :nodoc:
         base.extend(ClassMethods)
         base.class_attribute :context_management_configuration_value
@@ -193,9 +182,9 @@ module LittleGhost
         started_at = monotonic_time
         summary_request = ModelRequest.new(
           messages: [
-            Message.new(role: :system, content: SUMMARIZATION_PROMPT),
+            Message.new(role: :system, content: render_framework_prompt("context_management/summary/system_instruction")),
             *messages,
-            Message.new(role: :user, content: "Please summarize this conversation.")
+            Message.new(role: :user, content: render_framework_prompt("context_management/summary/request"))
           ],
           tools: [],
           settings: request.settings,

data/lib/little_ghost/agent/delegation.rb

@@ -17,8 +17,10 @@ module LittleGhost
     # Static declarations may be combined with a resolver that returns dynamic
     # Subagents::Definition objects. Managed conversations persist when a session
     # store is configured unless <tt>persist: false</tt> keeps them local to one
-    # invocation. An agent exposed as a tool starts with empty history unless
-    # <tt>preserve_context: true</tt> serializes calls and retains its history.
+    # invocation. A class-declared agent exposed as a tool starts with an empty
+    # history and a fresh run-scoped Agent for every call. Set
+    # <tt>preserve_context: true</tt> to serialize calls through one Agent and
+    # retain its history.
     #
     # Tool overrides must be classes. A delegated agent otherwise receives only
     # its own declared tools; it does not inherit the parent's registry. The
@@ -91,8 +93,9 @@ module LittleGhost
 
         # Exposes +agent_class+ as one ordinary tool.
         #
-        # Pass <tt>preserve_context: true</tt> to retain the delegated agent's
-        # conversational history between calls to that tool instance.
+        # By default, every tool call builds and closes a fresh delegated Agent.
+        # Pass <tt>preserve_context: true</tt> to serialize calls through one
+        # Agent and retain its conversational history between calls.
         def agent_as_tool(agent_class, name: nil, description: nil, model: nil, tools: nil,
           preserve_context: false)
           assembly_as_tool(

data/lib/little_ghost/agent/skills.rb

@@ -40,7 +40,8 @@ module LittleGhost
               paths:,
               resource_root: binding.run&.runtime&.skill_resource_root,
               workspace: binding.workspace,
-              sandbox: binding.sandbox
+              sandbox: binding.sandbox,
+              prompt_renderer: binding.agent.method(:render_framework_prompt)
             )
           )
           return [] if catalog.names.empty?
@@ -70,10 +71,6 @@ module LittleGhost
           end
           self.skills_configuration_value = options.merge(paths: configured_paths)
           tools CatalogTools
-          prompt_local(:skills_prompt) do
-            tool = tools.fetch("skills") if tools.names.include?("skills")
-            tool&.catalog&.discovery_prompt.to_s
-          end
           before_invocation :include_skills_prompt
         end
 
@@ -82,8 +79,13 @@ module LittleGhost
 
       private
 
+      def skills_prompt
+        tool = tools.fetch("skills") if tools.names.include?("skills")
+        tool&.catalog&.discovery_prompt.to_s
+      end
+
       def include_skills_prompt(payload)
-        prompt = prompt_locals[:skills_prompt].to_s
+        prompt = skills_prompt
         return Support::Callbacks.continue if prompt.empty?
 
         messages = payload.fetch(:messages).dup

data/lib/little_ghost/agent/tool_loop.rb

@@ -27,8 +27,6 @@ module LittleGhost
     # changed result resets that sequence, while a terminating repeat prevents
     # the duplicate tool body from running again.
     module ToolLoop
-      WARNING = "Repeated tool call detected. Change the approach or arguments before calling this tool again." # :nodoc:
-      FINAL_WARNING = "Final repeated tool call warning. Calling this tool again with identical arguments and result will stop the run." # :nodoc:
       TRACKED_INVOCATION_LIMIT = 1_000 # :nodoc:
 
       def self.included(base) # :nodoc:
@@ -120,7 +118,7 @@ module LittleGhost
           newly_terminated = false
           if repeat && repeat[:count] >= @tool_loop_terminate_at - 1
             unless state[:termination]
-              state[:termination] = "Stopped after detecting a repeated tool-call loop in #{tool_use.name.inspect}."
+              state[:termination] = render_framework_prompt("tools/loop/notices/termination", tool_name: tool_use.name)
               newly_terminated = true
             end
           end
@@ -165,7 +163,9 @@ module LittleGhost
         return Support::Callbacks.continue unless count == @tool_loop_warning_at || count == @tool_loop_terminate_at - 1
 
         action = (count == @tool_loop_warning_at) ? :warn : :final_warning
-        warning = (action == :warn) ? WARNING : FINAL_WARNING
+        warning = render_framework_prompt(
+          (action == :warn) ? "tools/loop/notices/warning" : "tools/loop/notices/final_warning"
+        )
         Instrumentation.publish(
           :tool_loop,
           operation_id: payload[:operation_id],

data/lib/little_ghost/agent.rb

@@ -39,18 +39,17 @@ module LittleGhost
   # an explicitly isolated setup.
   #
   # Agent declarations are inherited. Define a short prompt inline, or place a
-  # growing prompt in <tt>app/prompts/customer_support/system.erb</tt> for
+  # growing prompt in <tt>app/prompts/customer_support/system_prompt.erb</tt> for
   # +CustomerSupportAgent+. The {Prompts as Views guide}[rdoc-ref:docs/guides/prompt_views.md]
-  # explains conventional lookup, locals, and partials. Optional features such
-  # as skills, context management, loop detection, and delegation stay inactive
-  # until their DSL is used.
+  # explains conventional lookup, values prepared by the Agent, locals, and
+  # partials. Optional features such as skills, context management, loop
+  # detection, and delegation stay inactive until their DSL is used.
   #
   # Models may return text or locally validated structured data. LittleGhost
   # hides unexpected Tool exception messages from the model. See
   # Run[rdoc-ref:LittleGhost::Run] for outcomes, cancellation, and cleanup, and
   # Assembly[rdoc-ref:LittleGhost::Assembly] for the advanced run-scoped form.
   class Agent < Assembly
-    DEFAULT_SYSTEM_PROMPT = "You are a helpful agent." # :nodoc:
     DEFAULT_MAX_TOOL_RESULT_TOKENS = 10_000 # :nodoc:
     MAX_STRUCTURED_RESULT_BYTES = 1_000_000 # :nodoc:
     MAX_STRUCTURED_RESULT_DEPTH = 64 # :nodoc:
@@ -84,7 +83,6 @@ module LittleGhost
     class_attribute :system_prompt_builder_value
     class_attribute :tool_declarations_value, default: []
     class_attribute :code_mode_configuration_value
-    class_attribute :prompt_local_values, default: {}
     class_attribute :callback_values, default: Support::Callbacks.new(*CALLBACKS)
 
     class << self
@@ -284,16 +282,6 @@ module LittleGhost
 
       def code_mode_configuration = code_mode_configuration_value # :nodoc:
 
-      # Adds a named value or resolver to every prompt rendered for the agent.
-      def prompt_local(name, *values, &resolver)
-        raise ArgumentError, "Provide a prompt local value or block" if values.empty? && !resolver
-        raise ArgumentError, "Provide a prompt local value or block, not both" unless values.empty? || !resolver
-
-        self.prompt_local_values = prompt_local_values.merge(name.to_sym => resolver || values.fetch(0))
-      end
-
-      def prompt_local_resolvers = prompt_local_values # :nodoc:
-
       def callbacks = callback_values # :nodoc:
 
       CALLBACKS.each do |name|
@@ -539,7 +527,8 @@ module LittleGhost
     # The first form is the application-facing entrypoint. It may be reused for
     # independent concurrent calls and creates a fresh Run for each one. The
     # second form is run-scoped; Runtime builders supply its dependencies and it
-    # must not outlive or be shared outside its owning Run.
+    # must not outlive its owning Run. Calls on a run-scoped instance must be
+    # sequential. An overlapping call raises AgentBusyError when its stream begins.
     def initialize(
       model: nil,
       runtime: nil,
@@ -560,6 +549,8 @@ module LittleGhost
       standalone = model.nil? && run.nil?
       super(run:, runtime:, workspace:, sandbox:, standalone:)
       if standalone
+        @framework_prompts = FrameworkPrompts.new(paths: template_paths)
+        @framework_prompt_invocation_paths = [].freeze
         @owns_resources = true
         @closed = false
         @close_mutex = Mutex.new
@@ -570,6 +561,12 @@ module LittleGhost
 
       @model = model
       @runtime = runtime || run&.runtime
+      @framework_prompts = if @runtime
+        FrameworkPrompts.for_runtime(@runtime)
+      else
+        FrameworkPrompts.new(paths: template_paths)
+      end
+      @framework_prompt_invocation_paths = [].freeze
       @run = run
       @workspace = workspace || run&.workspace
       @sandbox = sandbox || run&.sandbox
@@ -606,6 +603,8 @@ module LittleGhost
       @assembly_transitions = {}
       @assembly_tool_batch_sizes = {}
       @assembly_transition = nil
+      @_little_ghost_invocation_mutex = Mutex.new
+      @_little_ghost_invocation_active = false
       raise ArgumentError, "max_turns must be at least 1" if @max_turns < 1
       raise ArgumentError, "max_tool_calls must be at least 1" if @max_tool_calls < 1
       raise ArgumentError, "max_tool_result_tokens must be at least 1" if @max_tool_result_tokens < 1
@@ -613,6 +612,7 @@ module LittleGhost
         resolved_runtime.runtime_hooks.find { |hook| hook.is_a?(Runtime::Hooks::Artifacts) }
       end
       apply_cancellation_decision!(run_callbacks(:after_initialize, self))
+      @_little_ghost_prompt_assign_baseline = prompt_application_state.freeze
     rescue
       @tool_registry&.close
       @code_mode_runtime&.close
@@ -643,7 +643,7 @@ module LittleGhost
     def request_assembly_transition(value, context:) # :nodoc:
       @assembly_transitions_mutex.synchronize do
         unless @assembly_tool_batch_sizes[context] == 1
-          raise ToolError, "An assembly transition must be the only tool call in a model response"
+          raise ToolError, render_framework_prompt("assembly/feedback/transition_only")
         end
         if @assembly_transitions.key?(context)
           raise ProtocolError, "Multiple assembly transitions were requested in one agent turn"
@@ -658,7 +658,7 @@ module LittleGhost
 
     # Adds an interjection and returns the model's immediate result details.
     #
-    # Use +target_operation_id+ when an agent has multiple active invocations.
+    # +target_operation_id+ may identify the active model operation.
     # Messages may contain only text, image, or document content. The returned
     # result value exposes +text+, +tool_calls?+, +interjection_ids+, and
     # +batch_key+; tool calls may continue after this result. Depend on these
@@ -729,11 +729,12 @@ module LittleGhost
     # Streams one invocation as StreamEvent objects.
     #
     # Agents built inside a run accept history, JSON-like context, cancellation,
-    # deadlines, settings, and trusted invocation template paths. An Agent
+    # deadlines, settings, and invocation-specific prompt roots. An Agent
     # instance may be streamed only by its owning Run. Every template path must
-    # be an application-created TrustedPath;
-    # the wrapper records a trust decision and must never contain unchecked
-    # request or model input.
+    # be an application-created TrustedPath, never a value selected by a request
+    # or model. A run-scoped Agent accepts one active invocation; enumerating an
+    # overlapping stream raises AgentBusyError. The instance may be invoked
+    # again after the first stream completes or fails.
     def stream(
       input = nil,
       history: nil,
@@ -778,18 +779,21 @@ module LittleGhost
       end
       settings = @model_settings.merge(settings)
       Enumerator.new do |events|
+        invocation_acquired = false
         interjections = AgentInterjections.new
-        run_context = RunContext.new(
-          state: context,
-          cancellation_token: cancellation_token,
-          deadline: deadline,
-          metadata: {agent_id: self.class.agent_id},
-          checkpoint:,
-          conversation_id:,
-          interjection_metadata:,
-          interjection_ids:
-        )
         begin
+          begin_invocation!
+          invocation_acquired = true
+          run_context = RunContext.new(
+            state: context,
+            cancellation_token: cancellation_token,
+            deadline: deadline,
+            metadata: {agent_id: self.class.agent_id},
+            checkpoint:,
+            conversation_id:,
+            interjection_metadata:,
+            interjection_ids:
+          )
           with_invocation(run_context) do
             execute(
               input,
@@ -808,23 +812,55 @@ module LittleGhost
           interjections.close(error)
           raise
         ensure
-          @code_mode_runtime&.close(context: run_context)
-          interjections.close(AgentInterjectionError.new("Agent finished before the interjection was delivered"))
-          unregister_interjections(interjections)
+          cleanup_error = nil
+          begin
+            @code_mode_runtime&.close(context: run_context) if run_context
+          rescue => error
+            cleanup_error = error
+          end
+          begin
+            interjections.close(AgentInterjectionError.new("Agent finished before the interjection was delivered"))
+          rescue => error
+            cleanup_error ||= error
+          ensure
+            begin
+              unregister_interjections(interjections)
+            ensure
+              end_invocation! if invocation_acquired
+            end
+          end
+          raise cleanup_error if cleanup_error
         end
       end
     end
 
-    # Materializes and freezes the prompt locals declared on the agent class.
-    def prompt_locals
-      self.class.prompt_local_resolvers.to_h do |name, resolver|
-        value = if resolver.respond_to?(:call)
-          resolver.parameters.empty? ? instance_exec(&resolver) : resolver.call(self)
-        else
-          resolver
-        end
-        [name, value]
-      end.freeze
+    # :call-seq:
+    #   system_prompt() -> Object
+    #
+    # Prepares application values for a file-backed system prompt. Override this
+    # method, assign instance variables, and read them from the ERB view:
+    #
+    #   def system_prompt
+    #     @company_name = "Northstar"
+    #   end
+    #
+    # In <tt>app/prompts/customer_support/system_prompt.erb</tt>:
+    #
+    #   You help customers of <%= @company_name %>.
+    #
+    # LittleGhost calls the action once before rendering the top-level prompt
+    # view. Partials share its prepared values without calling it again. Its
+    # return value is ignored. If it raises, the invocation fails with that
+    # exception. An inline prompt declared on the Agent class takes precedence
+    # and does not call this method.
+    #
+    # Each render starts with the application instance variables captured after
+    # the Agent's +after_initialize+ callbacks finish. LittleGhost copies the
+    # prepared values into the view, then restores the Agent's live instance
+    # variables, even when this method raises. Objects are not duplicated, so
+    # treat mutable values as read-only or assign a copy. Subclasses may call
+    # +super+ before preparing additional values.
+    def system_prompt
     end
 
     # The Tool registry available during this Agent run.
@@ -887,6 +923,73 @@ module LittleGhost
 
     private
 
+    PROTECTED_PROMPT_INSTANCE_VARIABLES = %i[
+      @active_assemblies @active_interjections @agent_path @agent_stream_path
+      @artifact_lifecycle @assembly_closed @assembly_definition @assembly_mutex
+      @assembly_tool_batch_sizes @assembly_transition @assembly_transitions
+      @assembly_transitions_mutex @close_mutex @closed @code_mode_declaration
+      @code_mode_runtime @delegation_activity @exclusive_tools_mutex @executor
+      @interjections_mutex @max_tool_calls @max_tool_result_tokens @max_turns
+      @model @model_settings @owns_resources @run @runtime @sandbox @standalone
+      @framework_prompts @framework_prompt_invocation_paths
+      @structured_output_strategy @task_runner @template_resolver @tool_loop_except
+      @tool_loop_fallback @tool_loop_mutex @tool_loop_runs @tool_loop_terminate_at
+      @tool_loop_warning_at @tool_registry @workspace
+      @_little_ghost_invocation_active @_little_ghost_invocation_mutex
+    ].freeze # :nodoc:
+
+    def begin_invocation!
+      @_little_ghost_invocation_mutex.synchronize do
+        if @_little_ghost_invocation_active
+          raise AgentBusyError,
+            "Agent is already handling an invocation; use the Agent class entrypoint or a fresh Agent for independent calls"
+        end
+
+        @_little_ghost_invocation_active = true
+      end
+    end
+
+    def end_invocation!
+      @_little_ghost_invocation_mutex.synchronize { @_little_ghost_invocation_active = false }
+    end
+
+    def prompt_view_assigns
+      names = prompt_application_instance_variables
+      names.to_h do |name|
+        [name.to_s.delete_prefix("@").to_sym, instance_variable_get(name)]
+      end
+    end
+
+    def prepare_prompt_view_assigns
+      saved = prompt_application_state
+      replace_prompt_application_state(@_little_ghost_prompt_assign_baseline)
+      begin
+        system_prompt
+        prompt_view_assigns
+      ensure
+        replace_prompt_application_state(saved)
+      end
+    end
+
+    def prompt_application_instance_variables
+      instance_variables.reject do |name|
+        PROTECTED_PROMPT_INSTANCE_VARIABLES.include?(name) || name.to_s.start_with?("@_little_ghost_")
+      end
+    end
+
+    def prompt_application_state
+      prompt_application_instance_variables.to_h do |name|
+        [name, instance_variable_get(name)]
+      end
+    end
+
+    def replace_prompt_application_state(state)
+      prompt_application_instance_variables.each { |name| remove_instance_variable(name) }
+      state.each do |name, value|
+        instance_variable_set(name, value)
+      end
+    end
+
     def entrypoint_payload(input, options)
       return options if input.nil?
       return input.merge(options) if input.is_a?(Hash)
@@ -911,12 +1014,7 @@ module LittleGhost
       Message.new(
         role: :user,
         content: [
-          Content::Text.new(text: <<~MESSAGE.strip),
-            Agent interjection:
-
-            Respond briefly in ordinary text before any tool calls, then continue the current task unless this
-            interjection asks you to finish.
-          MESSAGE
+          Content::Text.new(text: render_framework_prompt("agent/interjections/instructions")),
           *source.content
         ],
         metadata: source.metadata.merge(interjection.metadata).merge(
@@ -974,6 +1072,8 @@ module LittleGhost
       interjections:,
       interject_ready:
     )
+      previous_framework_prompt_invocation_paths = @framework_prompt_invocation_paths
+      @framework_prompt_invocation_paths = template_paths.freeze
       started_at = monotonic_time
       operation_id = SecureRandom.uuid
       events = agent_stream_events(
@@ -1322,6 +1422,8 @@ module LittleGhost
       metadata = model.details.to_h.merge(model_role: model.role)
       emit(events, :invocation_error, error:, usage: context.usage, metadata:)
       raise
+    ensure
+      @framework_prompt_invocation_paths = previous_framework_prompt_invocation_paths
     end
 
     def invoke_model(
@@ -1343,7 +1445,14 @@ module LittleGhost
       StructuredOutput.validate_tool_collision!(strategy, ordinary_tools) if strategy
       request = ModelRequest.new(
         messages: messages,
-        tools: model_tools(strategy ? strategy.tools(ordinary_tools) : ordinary_tools, context:, turn:),
+        tools: model_tools(
+          strategy ? strategy.tools(
+            ordinary_tools,
+            description: render_framework_prompt("structured_output/tools/result/description")
+          ) : ordinary_tools,
+          context:,
+          turn:
+        ),
         settings: settings,
         output_schema: strategy&.output_schema,
         tool_choice: strategy&.tool_choice(repair: structured_result_repair_due),
@@ -1573,7 +1682,11 @@ module LittleGhost
           }
         )
         if tool.is_a?(ToolError)
-          result = build_tool_result(tool_use_id: tool_use.id, content: tool.message, status: :error)
+          result = build_tool_result(
+            tool_use_id: tool_use.id,
+            content: render_framework_prompt("tools/feedback/unknown", name: tool_use.name),
+            status: :error
+          )
           finish_instrumentation(
             tool_handle,
             operation_id:,
@@ -1659,6 +1772,7 @@ module LittleGhost
             tool_result,
             tool_use:,
             run: @run,
+            agent: self,
             workspace:,
             context:
           )
@@ -1686,7 +1800,12 @@ module LittleGhost
         )
         ExecutedTool.new(result:, execution_result: tool_result)
       rescue ToolError => error
-        result = build_tool_result(tool_use_id: tool_use.id, content: error.message, status: :error)
+        content = if error.framework_prompt
+          render_framework_prompt(error.framework_prompt.key, **error.framework_prompt.locals)
+        else
+          error.message
+        end
+        result = build_tool_result(tool_use_id: tool_use.id, content:, status: :error)
         finish_instrumentation(
           tool_handle,
           operation_id:,
@@ -1746,7 +1865,7 @@ module LittleGhost
       content = if references.empty?
         result.content
       else
-        "#{result.content}\n\nArtifacts:\n#{references.join("\n")}"
+        [result.content, render_framework_prompt("artifacts/presentation/format/references", references:)].join("\n\n")
       end
 
       Tool::ExecutionResult.new(
@@ -1763,8 +1882,12 @@ module LittleGhost
       artifacts.filter_map do |artifact|
         next unless artifact.reference.is_a?(String) && artifact.bytes
 
-        details = [artifact.media_type, "#{artifact.bytes} bytes"].compact.join(", ")
-        "- #{artifact.reference} (#{details})"
+        render_framework_prompt(
+          "artifacts/presentation/format/reference",
+          reference: artifact.reference,
+          media_type: artifact.media_type,
+          bytes: artifact.bytes
+        )
       end
     end
 
@@ -1852,7 +1975,10 @@ module LittleGhost
       configuration = self.class.result_schema
       schema_name = configuration.fetch(:name)
       validate_structured_result_limits!(value)
-      errors = Tool::SchemaValidator.new(configuration.fetch(:schema)).validate(value)
+      errors = Tool::SchemaValidator.new(
+        configuration.fetch(:schema),
+        prompt_renderer: method(:render_framework_prompt)
+      ).validate(value)
       return "Structured result does not match its schema: #{errors.join("; ")}" unless errors.empty?
 
       context.submit_structured_result(
@@ -1873,7 +1999,7 @@ module LittleGhost
       tool_uses.map do |tool_use|
         build_tool_result(
           tool_use_id: tool_use.id,
-          content: "The structured result was invalid. Submit it again using the required schema.",
+          content: render_framework_prompt("structured_output/repair/feedback/invalid_result"),
           status: :error
         )
       end
@@ -1910,7 +2036,10 @@ module LittleGhost
     def redact_structured_result_message(message)
       Message.new(
         role: message.role,
-        content: "[Structured result #{self.class.result_schema.fetch(:name)} redacted]",
+        content: render_framework_prompt(
+          "structured_output/persistence/format/redaction",
+          schema_name: self.class.result_schema.fetch(:name)
+        ),
         metadata: message.metadata
       )
     end
@@ -1995,14 +2124,15 @@ module LittleGhost
     end
 
     def structured_result_repair_message
-      requirement = if @structured_output_strategy&.tool?
-        "Call #{@structured_output_strategy.schema_name} exactly once as your only tool call."
-      else
-        "Your final response must be JSON matching the configured output schema."
-      end
       Message.new(
         role: :user,
-        content: "#{requirement} You have one repair attempt. The previous structured result was invalid."
+        content: render_framework_prompt(
+          "structured_output/repair/request",
+          tool: @structured_output_strategy&.tool?,
+          schema_name: @structured_output_strategy&.schema_name,
+          repairs_remaining: 1,
+          feedback: render_framework_prompt("structured_output/repair/feedback/invalid_result")
+        )
       )
     end
 
@@ -2110,14 +2240,17 @@ module LittleGhost
       prompt = prompt.call(locals) if prompt.respond_to?(:call)
       return append_code_mode_instructions(prompt) if prompt
       template = self.class.system_template
-      return append_code_mode_instructions(DEFAULT_SYSTEM_PROMPT) if instance_of?(Agent) && run && !template
+      if instance_of?(Agent) && run && !template
+        return append_code_mode_instructions(render_framework_prompt("agent/system/default"))
+      end
 
-      template ||= "#{self.class.logical_path}/system" if run
+      template ||= "#{self.class.logical_path}/system_prompt" if run
       return nil unless template
 
       append_code_mode_instructions(@template_resolver.render(
         template,
         locals: locals,
+        assigns: prepare_prompt_view_assigns,
         invocation_paths: invocation_paths
       ))
     end
@@ -2146,6 +2279,27 @@ module LittleGhost
       LittleGhost::PromptResolver.new(paths:)
     end
 
+    public
+
+    def render_framework_prompt(key, **locals) # :nodoc:
+      @framework_prompts.render(
+        key,
+        locals:,
+        invocation_paths: @framework_prompt_invocation_paths,
+        agent_path: self.class.logical_path
+      )
+    end
+
+    def framework_prompt_scope # :nodoc:
+      {
+        framework_prompts: @framework_prompts,
+        invocation_paths: @framework_prompt_invocation_paths,
+        agent_path: self.class.logical_path
+      }.freeze
+    end
+
+    private
+
     def apply_cancellation_decision!(decision)
       raise CancelledError, decision.reason if decision.cancel?
     end
@@ -2305,7 +2459,13 @@ module LittleGhost
     end
 
     def truncated_tool_result(content)
-      Support::OutputTruncation.truncate_middle_with_token_budget(content, @max_tool_result_tokens).first
+      Support::OutputTruncation.truncate_middle_with_token_budget(
+        content,
+        @max_tool_result_tokens,
+        framework_prompts: @framework_prompts,
+        invocation_paths: @framework_prompt_invocation_paths,
+        agent_path: self.class.logical_path
+      ).first
     end
 
     def monotonic_time