lyman 0.2.1 → 0.3.0

data/harness/repl/think_filter.rb

@@ -0,0 +1,127 @@
+require_relative "style"
+
+# Thinking models prefix replies with <think>...</think> (the worker
+# normalizes separate-reasoning-field servers to the same convention). When
+# the reply arrives one fragment at a time we can't regex the whole thing, so
+# this streams a short preview of the thinking — the first few lines,
+# rendered as a dim "✻ …" aside rather than the literal tags — then elides
+# the rest once the model stops thinking.
+#
+# Emits [think_text, reply_text] pairs. Both stream straight to the terminal
+# today, but the split is the seam for reply-side processing (a markdown
+# renderer, say — mind that anything buffering the reply trades away its
+# token-by-token streaming, which is why this harness doesn't ship one).
+class ThinkFilter
+  OPEN = "<think>"
+  CLOSE = "</think>"
+  MARK = "✻ "
+  SNIPPET_LINES = 3
+  SNIPPET_CHARS = 240 # think blocks are often one long unwrapped paragraph
+
+  def initialize
+    @state = :start
+    @buffer = +""
+    @lines = 0
+    @chars = 0
+    @truncated = false
+  end
+
+  # Returns the printable portion of this fragment as a
+  # [think_text, reply_text] pair (either may be empty).
+  def filter(fragment)
+    @buffer << fragment
+    case @state
+    when :start then filter_start
+    when :thinking then filter_thinking
+    when :after_think then ["", filter_after_think]
+    when :passing then ["", take_buffer]
+    end
+  end
+
+  # Call when the message is complete: releases anything still held back
+  # (e.g. a reply that was nothing but "<thin"), and closes out the styling
+  # of a think block the model never closed itself.
+  def flush
+    case @state
+    when :start then ["", take_buffer]
+    when :thinking then [(@truncated ? "…" : "") + RESET, ""]
+    else ["", ""]
+    end
+  end
+
+  private
+
+  def take_buffer
+    out = @buffer
+    @buffer = +""
+    out
+  end
+
+  def filter_start
+    if @buffer.start_with?(OPEN)
+      @state = :thinking
+      @buffer = @buffer[OPEN.length..]
+      think, reply = filter_thinking
+      [DIM + MARK + think, reply]
+    elsif OPEN.start_with?(@buffer)
+      ["", ""] # could still become <think>; wait for more
+    else
+      @state = :passing
+      ["", take_buffer]
+    end
+  end
+
+  def filter_thinking
+    if (idx = @buffer.index(CLOSE))
+      thought = @buffer[0...idx]
+      @buffer = @buffer[(idx + CLOSE.length)..]
+      @state = :after_think
+      [snippet(thought) + (@truncated ? "…" : "") + RESET + "\n\n", filter_after_think]
+    else
+      # Keep any tail that could be the start of CLOSE split across
+      # fragments; preview the rest.
+      keep = partial_close_suffix
+      thought = @buffer[0, @buffer.length - keep.length]
+      @buffer = keep
+      [snippet(thought), ""]
+    end
+  end
+
+  # The leading portion of the thought that fits the preview budget.
+  def snippet(text)
+    return "" if @truncated
+    out = +""
+    text.each_char do |ch|
+      if @chars >= SNIPPET_CHARS || (ch == "\n" && @lines >= SNIPPET_LINES - 1)
+        @truncated = true
+        break
+      end
+      out << ch
+      @chars += 1
+      @lines += 1 if ch == "\n"
+    end
+    out
+  end
+
+  # We end the think preview with "\n\n" ourselves, so swallow the model's
+  # own whitespace between the close tag and the reply.
+  def filter_after_think
+    stripped = @buffer.lstrip
+    if stripped.empty?
+      @buffer = +""
+      ""
+    else
+      @state = :passing
+      @buffer = stripped
+      take_buffer
+    end
+  end
+
+  def partial_close_suffix
+    (1...CLOSE.length).reverse_each do |len|
+      tail = @buffer[-len, len]
+      return tail if tail && CLOSE.start_with?(tail)
+    end
+    +""
+  end
+end

data/harness/repl/tool_printer.rb

@@ -0,0 +1,36 @@
+require "cli/ui"
+require_relative "style"
+
+# Prints tool activity around the execution stage: the calls the model
+# requested on the way in, a ✓-and-result line on the way out. Results are
+# summarized to one line here — the full text is on the conversation, where
+# the model (and any logging side-worker) sees it.
+class ToolPrinter
+  RESULT_WIDTH = 60
+
+  def calls(conversation)
+    conversation.pending_tool_calls.each do |tool_call|
+      puts gray("  ⚙ #{tool_call.dig("function", "name")} #{tool_call.dig("function", "arguments")}")
+    end
+  end
+
+  def results(conversation)
+    messages = conversation.messages
+    request = messages.rindex { |m| m["role"] == "assistant" }
+    return unless request
+    names = (messages[request]["tool_calls"] || [])
+      .to_h { |tc| [tc["id"], tc.dig("function", "name")] }
+    messages[(request + 1)..].each do |message|
+      next unless message["role"] == "tool"
+      summary = gray("#{names[message["tool_call_id"]]} → #{summarize(message["content"])}")
+      puts "  #{CLI::UI.fmt("{{v}}")} #{summary}"
+    end
+  end
+
+  private
+
+  def summarize(text)
+    line = text.to_s.gsub(/\s+/, " ").strip
+    (line.length > RESULT_WIDTH) ? "#{line[0, RESULT_WIDTH - 1]}…" : line
+  end
+end

data/harness/repl/wait_spinner.rb

@@ -0,0 +1,28 @@
+require_relative "style"
+
+# The silence between sending a prompt and the first streamed token can be
+# long on a local model (prefill). cli-ui's spinner owns the calling thread
+# for the duration of a block, which can't express "spin until the first
+# delta arrives" — so this is the one hand-rolled widget: a background
+# spinner with a stop method. Quiet when output is piped.
+class WaitSpinner
+  FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏]
+
+  def start(label)
+    return unless TTY
+    stop
+    @thread = Thread.new do
+      FRAMES.cycle do |frame|
+        print "\r#{GRAY}#{frame} #{label}#{RESET}"
+        sleep 0.08
+      end
+    end
+  end
+
+  def stop
+    return unless @thread
+    @thread.kill.join
+    @thread = nil
+    print "\r\e[K" # erase the spinner line
+  end
+end

data/harness/repl.rb

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+#
+# The REPL archetype: a human drives the loop and decides when it ends.
+# One of three archetype shells — repl, daemon, script — around the same
+# circuit; see docs/design/harness-archetypes.md.
+#
+# The shell: state + a process. Deliberately boring.
+#
+# This file is the one legible wiring script — the circuit pattern from
+# docs/design/circuit-pattern.md, wired filter-in: one `pipeline.shift`
+# per turn, with all model⇄tool rounds happening inside the call.
+#
+# Everything the model does streams to the terminal as it happens —
+# pre-tool narration, tool calls, the final answer. Fitting the display
+# to the model (like hiding a <think> block) is this shell's job, not
+# the library's — the harness/repl/ files are that display layer. Their
+# dependencies (cli-ui for color and glyphs, reline for prompt
+# line-editing and history) stay out of the circuit; restyle or delete
+# them freely.
+
+# require_relative, not the load path: these are files planted beside this
+# script, not the lyman gem.
+require_relative "../lib/lyman"
+require_relative "repl/style"
+require_relative "repl/round_printer"
+require_relative "repl/tool_printer"
+require "cli/ui"
+require "reline"
+
+# This is a top-level wiring script by design; mixing the DSL into main
+# is the point, not an accident.
+include Shifty::DSL # standard:disable Style/MixinUsage
+
+$stdout.sync = true
+
+BASE_URL = ENV.fetch("LYMAN_BASE_URL", "http://localhost:11434/v1")
+MODEL = ENV.fetch("LYMAN_MODEL", "gemma4:latest")
+
+# ── Tools: schema and handler side by side, guts on the outside ────────────
+TOOLS = {
+  "current_time" => {
+    schema: {
+      "type" => "function",
+      "function" => {
+        "name" => "current_time",
+        "description" => "Returns the current local date and time",
+        "parameters" => {"type" => "object", "properties" => {}, "required" => []}
+      }
+    },
+    handler: ->(_args) { Time.now.strftime("%Y-%m-%d %H:%M:%S %Z") }
+  }
+}
+
+schemas = TOOLS.values.map { |tool| tool[:schema] }
+handlers = TOOLS.transform_values { |tool| tool[:handler] }
+
+# ── Shell state ─────────────────────────────────────────────────────────────
+conversation = Lyman::Conversation.new(
+  system_prompt: "You are a helpful assistant. Keep replies brief. " \
+    "Your replies are printed verbatim in a plain-text terminal: write prose, " \
+    "and avoid markdown and LaTeX markup."
+)
+rounds = [] # the circuit's queue — visible right here, not smuggled
+printer = RoundPrinter.new(MODEL)
+tool_printer = ToolPrinter.new
+
+# ── The circuit ─────────────────────────────────────────────────────────────
+pipeline =
+  source_worker { rounds.shift } |
+  side_worker { |_c| printer.start_round } |
+  Lyman::Workers.chat_completion(
+    base_url: BASE_URL, model: MODEL, tools: schemas,
+    on_delta: printer.method(:delta)
+  ) |
+  side_worker { |_c| printer.finish_round } |
+  relay_worker { |c|
+    (c.pending_tool_calls.empty? || c.runaway?) ? c.finish : c
+  } |
+  side_worker { |c| tool_printer.calls(c) unless c.finished? } |
+  Lyman::Workers.tool_execution(handlers) |
+  side_worker { |c| tool_printer.results(c) unless c.finished? } |
+  side_worker { |c| rounds << c unless c.finished? } |
+  filter_worker { |c| c.finished? }
+
+# ── Shell process ───────────────────────────────────────────────────────────
+puts CLI::UI.fmt("{{bold:lyman}} ⇢ {{magenta:#{MODEL}}} @ {{blue:#{BASE_URL}}}")
+puts
+puts gray(<<~HINTS.gsub(/^/, "  "))
+  exit:                 blank line, ctrl-c, or ctrl-d
+  change the model:     LYMAN_MODEL=qwen3.5:2b #{$PROGRAM_NAME}
+  change the endpoint:  LYMAN_BASE_URL=http://localhost:1234/v1 #{$PROGRAM_NAME}
+  available tools:      #{TOOLS.keys.join(", ")} — a ⚙ line appears when the model calls one
+HINTS
+
+loop do
+  puts
+  # Reline gives the prompt line editing and history, but emits screen-
+  # redraw escapes even when input is piped — so scripted runs get gets.
+  input = begin
+    if $stdin.tty?
+      Reline.readline(CLI::UI.fmt("{{cyan:you}}> "), true)&.strip
+    else
+      print "you> "
+      $stdin.gets&.strip
+    end
+  rescue Interrupt
+    nil # ctrl-c leaves like ctrl-d, not with a stack trace
+  end
+  break if input.nil? || input.empty?
+
+  # Conversation is an immutable value (shifty 0.6 freezes every handoff),
+  # so state flows in the open: enqueue a new conversation carrying the
+  # user's message, and rebind to the finished turn the circuit hands back.
+  rounds << conversation.with_user_message(input)
+  conversation = pipeline.shift
+end

data/harness/script.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+#
+# The script archetype: launched by something out of scope — cron, a
+# Makefile, a hand on a keyboard — with its work item in hand. It
+# processes that one item (however many model⇄tool rounds it takes) and
+# halts. One of three archetype shells — repl, daemon, script — around
+# the same circuit; see docs/design/harness-archetypes.md.
+#
+# The shell: state + a process. Here the process needs no loop at all —
+# the circuit still runs as many rounds as the model asks for, because
+# repetition lives in the pipeline (docs/design/circuit-pattern.md), not
+# in the shell. One enqueue, one shift, done.
+#
+# No display layer: output is the final answer on stdout, which is what
+# a cron job or a calling script wants to capture. Everything between —
+# the tool calls, the intermediate rounds — stays on the conversation,
+# where a logging side_worker can be spliced in if you want to see it.
+
+# require_relative, not the load path: these are files planted beside this
+# script, not the lyman gem.
+require_relative "../lib/lyman"
+
+# This is a top-level wiring script by design; mixing the DSL into main
+# is the point, not an accident.
+include Shifty::DSL # standard:disable Style/MixinUsage
+
+BASE_URL = ENV.fetch("LYMAN_BASE_URL", "http://localhost:11434/v1")
+MODEL = ENV.fetch("LYMAN_MODEL", "gemma4:latest")
+
+# ── Tools: schema and handler side by side, guts on the outside ────────────
+TOOLS = {
+  "current_time" => {
+    schema: {
+      "type" => "function",
+      "function" => {
+        "name" => "current_time",
+        "description" => "Returns the current local date and time",
+        "parameters" => {"type" => "object", "properties" => {}, "required" => []}
+      }
+    },
+    handler: ->(_args) { Time.now.strftime("%Y-%m-%d %H:%M:%S %Z") }
+  }
+}
+
+schemas = TOOLS.values.map { |tool| tool[:schema] }
+handlers = TOOLS.transform_values { |tool| tool[:handler] }
+
+# ── The work item ───────────────────────────────────────────────────────────
+# It arrives at launch: arguments if given, stdin otherwise — the two
+# channels a cron line or a calling script naturally speaks.
+task = ARGV.empty? ? $stdin.read.to_s.strip : ARGV.join(" ")
+abort "usage: #{$PROGRAM_NAME} TASK...   (or pipe the task on stdin)" if task.empty?
+
+# ── Shell state ─────────────────────────────────────────────────────────────
+conversation = Lyman::Conversation.new(
+  system_prompt: "You are a task runner. Complete the given task and reply " \
+    "with the result only — plain text, no markdown, no commentary."
+)
+rounds = [] # the circuit's queue — visible right here, not smuggled
+
+# ── The circuit ─────────────────────────────────────────────────────────────
+pipeline =
+  source_worker { rounds.shift } |
+  Lyman::Workers.chat_completion(base_url: BASE_URL, model: MODEL, tools: schemas) |
+  relay_worker { |c|
+    (c.pending_tool_calls.empty? || c.runaway?) ? c.finish : c
+  } |
+  Lyman::Workers.tool_execution(handlers) |
+  side_worker { |c| rounds << c unless c.finished? } |
+  filter_worker { |c| c.finished? }
+
+# ── Shell process ───────────────────────────────────────────────────────────
+# Enqueue before shifting — never pull the source while the queue is empty
+# (the nil footgun: a nil from a source ends the stream permanently).
+# Conversation is an immutable value (shifty 0.6 freezes every handoff):
+# with_user_message returns a new conversation, and the finished turn
+# comes back from the pipeline.
+rounds << conversation.with_user_message(task)
+result = pipeline.shift
+
+puts result.last_assistant_content

data/lib/lyman/cli/commands/new.rb

@@ -62,8 +62,11 @@ module Lyman
             Next steps:
               cd #{name}
               bundle install
-              ruby harness/chat.rb   # defaults to Ollama at http://localhost:11434/v1
+              ruby harness/repl.rb   # defaults to Ollama at http://localhost:11434/v1
               lyman doctor           # smoke-test the pipeline
+
+            The repl is one of three harness archetypes; the other two are a
+            `lyman add` away (daemon_harness, script_harness).
           EPILOGUE
         end
       end

data/lib/lyman/cli/doctor_check.rb

@@ -6,7 +6,7 @@
 # process's own, and it's the client's bundle — not the CLI's — that needs
 # to resolve shifty).
 #
-# Wires the same circuit shape as harness/chat.rb (docs/design/
+# Wires the same circuit shape as harness/repl.rb (docs/design/
 # circuit-pattern.md): a queue-backed source, the model⇄tool round, the
 # finish/requeue plumbing. The only substitution is the transport: a stub
 # stands in at the chat_completion seam. That's legitimate, not a mock
@@ -20,13 +20,14 @@ require "./lib/lyman"
 include Shifty::DSL # standard:disable Style/MixinUsage
 
 conversation = Lyman::Conversation.new(system_prompt: "doctor")
-conversation.add_user_message("ping the tool once, then answer")
-rounds = [] # the circuit's queue, shell scope — mirrors harness/chat.rb
+  .with_user_message("ping the tool once, then answer")
+rounds = [] # the circuit's queue, shell scope — mirrors harness/repl.rb
 
 # Stands in for Lyman::Workers.chat_completion: round 1 calls the "ping"
 # tool, round 2 answers plainly. A real transport wouldn't know the round
 # count in advance, but the seam only cares that something plays by the
-# wire's rules — append an assistant message, bump the round counter.
+# wire's rules — hand off a new conversation with the assistant message
+# appended (with_assistant_message also counts the round).
 call_count = 0
 stub_transport = relay_worker do |c|
   call_count += 1
@@ -46,17 +47,14 @@ stub_transport = relay_worker do |c|
     else
       {"role" => "assistant", "content" => "done"}
     end
-  c.add_assistant_message(message)
-  c.rounds += 1
-  c
+  c.with_assistant_message(message)
 end
 
 pipeline =
   source_worker { rounds.shift } |
   stub_transport |
   relay_worker { |c|
-    c.finish! if c.pending_tool_calls.empty? || c.runaway?
-    c
+    (c.pending_tool_calls.empty? || c.runaway?) ? c.finish : c
   } |
   Lyman::Workers.tool_execution({"ping" => ->(_) { "pong" }}) |
   side_worker { |c| rounds << c unless c.finished? } |

data/lib/lyman/cli/registry.rb

@@ -32,11 +32,62 @@ module Lyman
           role: :managed,
           description: "Relay worker: executes pending tool calls"
         },
-        "harness" => {
-          source: "harness/chat.rb",
-          dest: "harness/chat.rb",
+        # The three harness archetypes (docs/design/harness-archetypes.md):
+        # same circuit, different shells. `new` plants the repl — the
+        # archetype you can talk to on day one; the other two are opt-in
+        # (`lyman add daemon_harness` / `lyman add script_harness`) because a
+        # narrow, purpose-built agent wants one shell shape, not three.
+        "repl_harness" => {
+          source: "harness/repl.rb",
+          dest: "harness/repl.rb",
           role: :owned,
-          description: "The wiring script — yours from day one; lyman never updates it"
+          description: "The REPL archetype: a human drives the loop — yours from day one; lyman never updates it"
+        },
+        "daemon_harness" => {
+          source: "harness/daemon.rb",
+          dest: "harness/daemon.rb",
+          role: :owned,
+          optional: true,
+          description: "The daemon archetype: launch once, loop on an inbound event stream indefinitely"
+        },
+        "script_harness" => {
+          source: "harness/script.rb",
+          dest: "harness/script.rb",
+          role: :owned,
+          optional: true,
+          description: "The script archetype: take one work item at launch, process it, halt"
+        },
+        # The repl's display layer, one artifact per widget so ownership —
+        # and any drift `lyman diff` reports — stays per-file, not per-blob.
+        "repl_style" => {
+          source: "harness/repl/style.rb",
+          dest: "harness/repl/style.rb",
+          role: :owned,
+          description: "Terminal styling codes and the gray() helper shared by the repl display"
+        },
+        "think_filter" => {
+          source: "harness/repl/think_filter.rb",
+          dest: "harness/repl/think_filter.rb",
+          role: :owned,
+          description: "Streams a dim preview of <think> blocks, then elides the rest"
+        },
+        "wait_spinner" => {
+          source: "harness/repl/wait_spinner.rb",
+          dest: "harness/repl/wait_spinner.rb",
+          role: :owned,
+          description: "Background spinner for the silence before the first streamed token"
+        },
+        "round_printer" => {
+          source: "harness/repl/round_printer.rb",
+          dest: "harness/repl/round_printer.rb",
+          role: :owned,
+          description: "Streams one round to the terminal: spinner, model label, think preview, reply"
+        },
+        "tool_printer" => {
+          source: "harness/repl/tool_printer.rb",
+          dest: "harness/repl/tool_printer.rb",
+          role: :owned,
+          description: "Prints tool calls on the way in, summarized results on the way out"
         },
         "claude_md" => {
           source: "templates/CLAUDE.md",
@@ -103,9 +154,9 @@ module Lyman
         ARTIFACTS.select { |_, spec| spec[:role] == :managed }
       end
 
-      # What `new` plants: everything except opt-in artifacts (those exist
-      # for situations a fresh scaffold can't be in, like a pre-existing
-      # CLAUDE.md — reach them with `lyman add`).
+      # What `new` plants: everything except opt-in artifacts — alternates a
+      # fresh scaffold shouldn't presume (the daemon and script archetypes,
+      # the skill variant of CLAUDE.md). Reach them with `lyman add`.
       def self.default
         ARTIFACTS.reject { |_, spec| spec[:optional] }
       end

data/lib/lyman/cli/version.rb

@@ -2,6 +2,6 @@ module Lyman
   module CLI
     # The gem's own version — distinct from any artifact's `planted_at`.
     # This is what the manifest's top-level `lyman:` key records.
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

data/lib/lyman/conversation.rb

@@ -3,63 +3,64 @@ module Lyman
   # conversation so far, plus the control data workers consult to decide
   # *whether* to act (never *which of several things* to do).
   #
+  # An immutable value. Shifty 0.6 deep-freezes every value at a worker
+  # boundary (the :frozen handoff policy), so change is expressed as new
+  # values: each with_* method returns a new Conversation and leaves the
+  # receiver untouched. Data#with structurally shares the unchanged
+  # members — safe precisely because handed-off values are frozen.
+  #
   # Messages use string keys throughout, for clean round-tripping with
   # OpenAI-compatible wire formats.
-  class Conversation
-    attr_reader :messages
-    attr_accessor :rounds, :max_rounds
-
-    def initialize(system_prompt: nil, max_rounds: 10)
-      @messages = []
-      @messages << {"role" => "system", "content" => system_prompt} if system_prompt
-      @rounds = 0
-      @max_rounds = max_rounds
-      @finished = false
+  class Conversation < Data.define(:messages, :rounds, :max_rounds, :finished)
+    def initialize(system_prompt: nil, messages: nil, rounds: 0, max_rounds: 10, finished: false)
+      messages ||= system_prompt ? [{"role" => "system", "content" => system_prompt}] : []
+      super(messages: messages, rounds: rounds, max_rounds: max_rounds, finished: finished)
     end
 
-    def add_user_message(text)
-      @messages << {"role" => "user", "content" => text}
-      @finished = false
-      @rounds = 0
-      self
+    def with_user_message(text)
+      with(
+        messages: messages + [{"role" => "user", "content" => text}],
+        rounds: 0,
+        finished: false
+      )
     end
 
-    def add_assistant_message(message)
-      @messages << message
-      self
+    # A round *is* one model reply, so the counter lives here rather than
+    # in the transport worker — swap the transport and the runaway guard
+    # still can't be forgotten.
+    def with_assistant_message(message)
+      with(messages: messages + [message], rounds: rounds + 1)
     end
 
-    def add_tool_result(tool_call_id, content)
-      @messages << {
+    def with_tool_result(tool_call_id, content)
+      with(messages: messages + [{
         "role" => "tool",
         "tool_call_id" => tool_call_id,
         "content" => content
-      }
-      self
+      }])
     end
 
     def pending_tool_calls
-      last = @messages.last
+      last = messages.last
       return [] unless last && last["role"] == "assistant"
       last["tool_calls"] || []
     end
 
     def last_assistant_content
-      message = @messages.rfind { |m| m["role"] == "assistant" }
+      message = messages.rfind { |m| m["role"] == "assistant" }
       message && message["content"]
     end
 
-    def finish!
-      @finished = true
-      self
+    def finish
+      with(finished: true)
     end
 
     def finished?
-      @finished
+      finished
     end
 
     def runaway?
-      @rounds >= @max_rounds
+      rounds >= max_rounds
     end
   end
 end

data/lib/lyman/workers/chat_completion.rb

@@ -8,8 +8,8 @@ module Lyman
     extend Shifty::DSL
 
     # Relay worker: sends the conversation to an OpenAI-compatible chat
-    # completions endpoint and appends the assistant's reply (which may
-    # include tool calls). Increments the conversation's round counter.
+    # completions endpoint and hands off a new conversation with the
+    # assistant's reply (which may include tool calls) appended.
     #
     # Pass an on_delta callable to stream: it receives each content
     # fragment as it arrives. The worker still returns the conversation
@@ -42,9 +42,7 @@ module Lyman
             fetch_message(http, uri, payload)
           end
 
-        conversation.add_assistant_message(message)
-        conversation.rounds += 1
-        conversation
+        conversation.with_assistant_message(message)
       end
     end