anima-core 1.2.0 → 1.4.0

data/lib/tools/subagent_prompts.rb

@@ -1,23 +1,59 @@
 # frozen_string_literal: true
 
 module Tools
-  # Shared prompt fragments and nickname logic for tools that spawn sub-agent sessions.
+  # Shared prompt fragments and spawn logic for tools that create sub-agent sessions.
   # Included by {SpawnSubagent} and {SpawnSpecialist} to avoid duplication.
   module SubagentPrompts
-    COMMUNICATION_INSTRUCTION = "Your text messages are automatically forwarded to the parent agent. " \
-      "When you finish, write your final summary and stop — no special tool needed. " \
-      "If you need clarification, just ask — the parent can reply."
+    # Prepended to every sub-agent's stored prompt after nickname assignment.
+    # Establishes identity before any other instruction.
+    IDENTITY_TEMPLATE = "You are %s, a sub-agent of the primary agent."
+
+    COMMUNICATION_INSTRUCTION = "Your messages reach the parent automatically. " \
+      "Ask if you need clarification — the parent can reply."
 
     private
 
-    # Runs the analytical brain synchronously to assign a nickname.
+    # Creates the sub-agent's Goal from the task description, inserts the
+    # task as the first user message, and pins it to the Goal so it survives
+    # viewport eviction for as long as the Goal is active.
+    #
+    # @param child [Session] the newly created child session
+    # @param task [String] the task description
+    # @return [void]
+    def create_goal_with_pinned_task(child, task)
+      goal = child.goals.create!(description: task)
+      message = child.create_user_message(task)
+      pin = PinnedMessage.create!(
+        message: message,
+        display_text: task.truncate(PinnedMessage::MAX_DISPLAY_TEXT_LENGTH)
+      )
+      GoalPinnedMessage.create!(goal: goal, pinned_message: pin)
+    end
+
+    # Runs the analytical brain synchronously to assign a nickname,
+    # then prepends identity context to the stored prompt.
     # Falls back to a sequential "agent-N" name on any failure.
+    # Identity injection runs in +ensure+ so it applies to both
+    # brain-assigned and fallback nicknames.
     def assign_nickname_via_brain(child)
       AnalyticalBrain::Runner.new(child).call
       child.reload
     rescue => error
       Rails.logger.warn("Sub-agent nickname assignment failed: #{error.message}")
       child.update!(name: fallback_nickname)
+    ensure
+      inject_identity_context(child)
+    end
+
+    # Prepends identity context (nickname + sub-agent status) to the child's
+    # stored prompt. Called after nickname assignment so the sub-agent knows
+    # who it is from first token.
+    #
+    # @param child [Session] the child session with a nickname already set
+    # @return [void]
+    def inject_identity_context(child)
+      identity = format(IDENTITY_TEMPLATE, child.name)
+      child.update!(prompt: "#{identity}\n#{child.prompt}")
     end
 
     def fallback_nickname

data/lib/tools/think.rb

@@ -13,6 +13,10 @@ module Tools
   # - **inner** (default) — silent reasoning, visible only in verbose/debug
   # - **aloud** — narration shown in all view modes with a thought bubble
   #
+  # The +maxLength+ on thoughts is controlled by +thinking_budget+ in settings.
+  # Sub-agents receive half the main agent's budget — their tasks are scoped
+  # and less complex, so runaway reasoning is a stronger signal of confusion.
+  #
   # @example Silent planning between tool calls
   #   think(thoughts: "Three auth failures — likely a config issue, not individual tests.")
   #
@@ -23,6 +27,8 @@ module Tools
 
     def self.description = "Think out loud or silently."
 
+    # Schema is static — maxLength is injected at runtime by the registry
+    # via {#dynamic_schema} when session context is available.
     def self.input_schema
       {
         type: "object",
@@ -38,6 +44,23 @@ module Tools
       }
     end
 
+    # @param session [Session, nil] current session for budget calculation
+    def initialize(session: nil, **)
+      @session = session
+    end
+
+    # Returns the tool schema with a thinking budget applied as maxLength
+    # on the thoughts property. Sub-agents get half the budget.
+    #
+    # @return [Hash] Anthropic tool schema with maxLength constraint
+    def dynamic_schema
+      schema = self.class.schema.deep_dup
+      budget = Anima::Settings.thinking_budget
+      budget /= 2 if @session&.sub_agent?
+      schema[:input_schema][:properties][:thoughts][:maxLength] = budget
+      schema
+    end
+
     # @param input [Hash] with "thoughts" and optional "visibility"
     # @return [String] acknowledgement — the value is in the call, not the result
     def execute(input)

data/lib/tools/write.rb

@@ -15,7 +15,7 @@ module Tools
   #   tool.execute("path" => "README.md", "content" => "# Title\n")
   #   # => "Wrote 9 bytes to /home/user/project/README.md"
   class Write < Base
-    def self.tool_name = "write"
+    def self.tool_name = "write_file"
 
     def self.description = "Write file."