openc3 7.1.1 → 7.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 719b55747a7004cc44da1976c3f15eec6c67a3fca702b56792862f59f02cb8b5
-  data.tar.gz: c80082e75c059dac71d15a56264cba9c968f82c494e564e33b598c75ac01a6c2
+  metadata.gz: 13ecd5ed69a40943e0ceb4732af0922106d73ba3e28c7e10521e3cbcbb2728c9
+  data.tar.gz: e8a55a75e964de92cdc8fa9a27091d472437004a0775a05c894d4a16d5232677
 SHA512:
-  metadata.gz: 5b3c1ca82717f1debd25ab4a6ac0239aa9baee2b5f736f61b7f52103397b608ab3de8fd0d50e10f0a4481b507b2a519987a4c4c68f7d0f3770cd48f3e165b8eb
-  data.tar.gz: d2bc96742a2555be7c8149dd728155a76ba7c1a16474eb26a36388bdedaacc1fba9c447ab373beebd8fd58ac81248541531de1a163bc156be195c76e34b515f2
+  metadata.gz: 77c7ed5bcae0862bf8d7ccdeefbc79cdc814b04501831e5de5a2b7b1d685420f731da2bb230435a1d091697156ab1d58a40cf793869da48e191b7c87ccbffea9
+  data.tar.gz: 90571e3012ae117610314df3d32d67d77a843f2de8edb2c9b51bab3335cf0618e7301a9ba0c55616acad6a2d0ca1b4634924531f657bd438c0fd490aeca6a327

data/bin/openc3cli

@@ -671,30 +671,18 @@ def cli_script_list(args, options)
 end
 
 def parse_suite_runner_options(options)
-  suite_runner = nil
   # suite must be given to enable Suite Runner execution
-  if options[:suite]
-    suite_runner = {}
-    suite_runner['suite'] = options[:suite]
-    if options[:group]
-      suite_runner['group'] = options[:group]
-      # script requires group to be set
-      if options[:script]
-        suite_runner['script'] = options[:script]
-      end
-    end
-    if options[:method]
-      suite_runner['method'] = options[:method]
-    else
-      suite_runner['method'] = 'start'
-    end
-    if options[:options]
-      suite_runner['options'] = options[:options].split(',')
-    else
-      suite_runner['options'] = ["continueAfterError"]
-    end
-  end
-  return suite_runner
+  return nil unless options[:suite]
+  require 'openc3/script/suite_runner'
+  # Build the canonical hash via the shared helper so the CLI applies the same
+  # shape, defaults, and validation (e.g. script requires group) as execution.
+  return OpenC3::SuiteRunner.build_options(
+    suite: options[:suite],
+    group: options[:group],
+    script: options[:script],
+    method: options[:method],
+    options: options[:options]&.split(','),
+  )
 end
 
 def cli_script_run(args, options)

data/data/config/command_modifiers.yaml

@@ -417,12 +417,12 @@ VALIDATOR:
                 return [False, "TGT PKT ITEM is 0"]
             self.cmd_acpt_cnt = tlm("INST HEALTH_STATUS CMD_ACPT_CNT")
             # Return true to indicate Success, false to indicate Failure,
-            # and nil to indicate Unknown. The second value is the optional message.
+            # and None to indicate Unknown. The second value is the optional message.
             return [True, None]
 
         def post_check(self, command):
             wait_check(f"INST HEALTH_STATUS CMD_ACPT_CNT > {self.cmd_acpt_cnt}", 10)
             # Return true to indicate Success, false to indicate Failure,
-            # and nil to indicate Unknown. The second value is the optional message.
+            # and None to indicate Unknown. The second value is the optional message.
             return [True, None]
   since: 5.19.0

data/data/config/interface_modifiers.yaml

@@ -1,11 +1,16 @@
 ---
 MAP_TARGET:
   summary: Maps a target name to an interface
+  description: See [Mapping Targets to Interfaces](/docs/configuration/interfaces#mapping-targets-to-interfaces) for more information.
   parameters:
     - name: Target Name
       required: true
       description: Target name to map to this interface
       values: .+
+    - name: Enabled State
+      required: false
+      description: Initial enabled state of the target on this interface. Defaults to ENABLED.
+      values: ["ENABLED", "DISABLED"]
   ruby_example: |
     INTERFACE DATA_INT tcpip_client_interface.rb host.docker.internal 8080 8081 10.0 nil BURST
       MAP_TARGET DATA
@@ -14,12 +19,17 @@ MAP_TARGET:
       MAP_TARGET DATA
 MAP_CMD_TARGET:
   summary: Maps a target name to an interface for commands only
+  description: See [Mapping Targets to Interfaces](/docs/configuration/interfaces#mapping-targets-to-interfaces) for more information.
   since: 5.2.0
   parameters:
     - name: Target Name
       required: true
       description: Command target name to map to this interface
       values: .+
+    - name: Enabled State
+      required: false
+      description: Initial enabled state of the command target on this interface. Defaults to ENABLED.
+      values: ["ENABLED", "DISABLED"]
   ruby_example: |
     INTERFACE CMD_INT tcpip_client_interface.rb host.docker.internal 8080 8081 10.0 nil BURST
       MAP_CMD_TARGET DATA # Only DATA commands go on the CMD_INT interface
@@ -28,12 +38,17 @@ MAP_CMD_TARGET:
       MAP_CMD_TARGET DATA # Only DATA commands go on the CMD_INT interface
 MAP_TLM_TARGET:
   summary: Maps a target name to an interface for telemetry only
+  description: See [Mapping Targets to Interfaces](/docs/configuration/interfaces#mapping-targets-to-interfaces) for more information.
   since: 5.2.0
   parameters:
     - name: Target Name
       required: true
       description: Telemetry target name to map to this interface
       values: .+
+    - name: Enabled State
+      required: false
+      description: Initial enabled state of the telemetry target on this interface. Defaults to ENABLED.
+      values: ["ENABLED", "DISABLED"]
   ruby_example: |
     INTERFACE TLM_INT tcpip_client_interface.rb host.docker.internal 8080 8081 10.0 nil BURST
       MAP_TLM_TARGET DATA # Only DATA telemetry received on TLM_INT interface

data/data/config/item_modifiers.yaml

@@ -111,20 +111,27 @@ CONVERTED_DATA:
       values: \d+
 LIMITS:
   summary: Defines a set of limits for a telemetry item
-  description: If limits are violated a message is printed in the Command and Telemetry Server
+  description: |
+    If limits are violated a message is printed in the Command and Telemetry Server
     to indicate an item went out of limits. Other tools also use this information
     to update displays with different colored telemetry items or other useful information.
     The concept of "limits sets" is defined to allow for different limits values
     in different environments. For example, you might want tighter or looser limits
     on telemetry if your environment changes such as during thermal vacuum testing.
+
+    A DEFAULT limits set is required for every telemetry item with limits. If you
+    define additional named sets (e.g. TVAC), the DEFAULT set must be defined first.
+    Attempting to define a named set before DEFAULT will raise an error of the form
+    "DEFAULT limits set must be defined for TARGET PACKET ITEM before setting limits set NAME".
   example: |
     LIMITS DEFAULT 3 ENABLED -80.0 -70.0 60.0 80.0 -20.0 20.0
     LIMITS TVAC 3 ENABLED -80.0 -30.0 30.0 80.0
   parameters:
     - name: Limits Set
       required: true
-      description: Name of the limits set. If you have no unique limits sets use
-        the keyword DEFAULT.
+      description: Name of the limits set. A DEFAULT set is required and must be
+        defined before any other named sets for this item. If you have no unique
+        limits sets use the keyword DEFAULT.
       values: .+
     - name: Persistence
       required: true

data/data/config/target.yaml

@@ -170,3 +170,20 @@ TARGET:
           values: \d+
       example: |
         DB_SHARD 0
+    STORED_LIMITS_MODE:
+      summary: Controls how limits are evaluated for stored (non-real-time) telemetry packets
+      description:
+        Sets the limits handling policy for packets where the stored flag is true
+        (e.g., packets from file interfaces or historical data replay).
+        PROCESS processes limits normally including logging and reactions.
+        LOG evaluates limits and logs state changes but does not trigger limits reactions
+        or update the current limits state used by the API.
+        DISABLE skips limits processing entirely for stored packets.
+      since: 7.2.1
+      parameters:
+        - name: Mode
+          required: true
+          description: "PROCESS (default), LOG, or DISABLE"
+          values: ^(PROCESS|LOG|DISABLE)$
+      example: |
+        STORED_LIMITS_MODE DISABLE

data/data/config/widgets.yaml

@@ -1579,7 +1579,10 @@ Canvas Widgets:
   collection:
     CANVAS:
       summary: Layout widget for the other canvas widgets
-      description: All canvas widgets must be enclosed within a CANVAS widget.
+      description:
+        All canvas widgets must be enclosed within a CANVAS widget.
+        The canvas background defaults to white. Use SETTING BACKCOLOR to set a
+        different background color.
       warning: The canvas coordinate frame places (0,0) in the upper-left corner of the canvas.
       parameters:
         - name: Width
@@ -1590,6 +1593,30 @@ Canvas Widgets:
           required: true
           description: Height of the canvas
           values: .+
+      settings:
+        BACKCOLOR:
+          summary: Sets the background color of the canvas
+          since: 7.2.1
+          parameters:
+            - name: Color name or Red value
+              required: true
+              description: Common name for the color, e.g. 'black', 'red', etc.
+                Alternatively if two more parameters are passed this is the
+                Red value of the RGB value
+              values: .+
+            - name: Green value
+              required: false
+              description: Green value of the RGB value
+              values: .+
+            - name: Blue value
+              required: false
+              description: Blue value of the RGB value
+              values: .+
+      example: |
+        CANVAS 100 50
+          SETTING BACKCOLOR 17 21 28
+          CANVASLABEL 5 30 "Dark canvas" 18 white
+        END
     CANVASLABEL:
       summary: Draws text onto the canvas
       parameters:

data/lib/openc3/accessors/binary_accessor.rb

@@ -108,6 +108,10 @@ module OpenC3
 
     def handle_read_variable_bit_size(item, _buffer)
       length_value = @packet.read(item.variable_bit_size['length_item_name'], :CONVERTED)
+      # length_value can be nil when reading an undersized packet where the length
+      # item falls outside the buffer bounds
+      raise "Length value #{item.variable_bit_size['length_item_name']} for item #{item.name} is nil" if length_value.nil?
+
       if item.array_size
         item.array_size = (length_value * item.variable_bit_size['length_bits_per_count']) + item.variable_bit_size['length_value_bit_offset']
       else

data/lib/openc3/api/cmd_api.rb

@@ -450,7 +450,7 @@ module OpenC3
 
     # NOTE: When adding new keywords to this method, make sure to update script/commands.rb
     def _cmd_implementation(method_name, *args, range_check:, hazardous_check:, raw:, timeout: nil, log_message: nil, manual: false, validate: true, queue: nil,
-                            scope: $openc3_scope, token: $openc3_token, **kwargs)
+                            queue_username: nil, scope: $openc3_scope, token: $openc3_token, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       unless [nil, true, false].include?(log_message)
         raise "Invalid log_message parameter: #{log_message}. Must be true or false."
@@ -535,6 +535,10 @@ module OpenC3
         'log_message' => log_message.to_s,
         'obfuscated_items' => packet['obfuscated_items'].to_s
       }
+      # Record the original queuing user (author) separately from 'username' (the
+      # user or process that actually executed the command). Command History shows
+      # 'username' as "Executed By" and queue_username as "Queued By".
+      command['queue_username'] = queue_username if queue_username
       # Users have to explicitly opt into a default queue by setting the OPENC3_DEFAULT_QUEUE
       # At which point ALL commands will go to that queue unless they specifically opt out with queue: false
       if ENV['OPENC3_DEFAULT_QUEUE'] && queue.nil?

data/lib/openc3/api/limits_api.rb

@@ -17,6 +17,7 @@
 
 require 'openc3/api/target_api'
 require 'openc3/models/cvt_model'
+require 'openc3/packets/packet_item'
 
 module OpenC3
   module Api
@@ -29,12 +30,14 @@ module OpenC3
                        'disable_limits',
                        'get_limits',
                        'set_limits',
+                       'set_state_color',
                        'get_limits_groups',
                        'enable_limits_group',
                        'disable_limits_group',
                        'get_limits_sets',
                        'set_limits_set',
                        'get_limits_set',
+                       'delete_limits_set',
                        'get_limits_events',
                      ])
 
@@ -251,6 +254,50 @@ module OpenC3
       LimitsEventTopic.write(event, scope: scope)
     end
 
+    # Change the color associated with a telemetry item state in realtime.
+    # Items with states use the state color (GREEN, YELLOW, RED) to determine
+    # their limits state rather than numeric red/yellow/green limits.
+    #
+    # @param target_name [String] Target name
+    # @param packet_name [String] Packet name
+    # @param item_name [String] Item name
+    # @param state_name [String] Name of the state to change (e.g. 'CONNECTED')
+    # @param color [String] New color for the state. Must be GREEN, YELLOW, or RED.
+    def set_state_color(target_name, packet_name, item_name, state_name, color,
+                        manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
+      state_name = state_name.to_s.upcase
+      color = color.to_s.upcase
+      unless PacketItem::STATE_COLORS.include?(color.intern)
+        raise "Invalid state color #{color}. Must be one of #{PacketItem::STATE_COLORS.join(' ')}."
+      end
+      packet = TargetModel.packet(target_name, packet_name, scope: scope)
+      found_item = nil
+      packet['items'].each do |item|
+        if item['name'] == item_name
+          unless item['states'] && item['states'][state_name]
+            raise "State '#{state_name}' does not exist for item '#{target_name} #{packet_name} #{item_name}'"
+          end
+          item['states'][state_name]['color'] = color
+          # Defining a state color implies limits are enabled for the item
+          item['limits'] ||= {}
+          item['limits']['enabled'] = true
+          found_item = item
+          break
+        end
+      end
+      raise "Item '#{target_name} #{packet_name} #{item_name}' does not exist" unless found_item
+      message = "Setting '#{target_name} #{packet_name} #{item_name}' state #{state_name} color to #{color}"
+      Logger.info(message, scope: scope)
+
+      TargetModel.set_packet(target_name, packet_name, packet, scope: scope)
+
+      event = { type: :LIMITS_STATE_COLOR, target_name: target_name, packet_name: packet_name,
+                item_name: item_name, state_name: state_name, color: color,
+                time_nsec: Time.now.to_nsec_from_epoch, message: message }
+      LimitsEventTopic.write(event, scope: scope)
+    end
+
     # Returns all limits_groups and their members
     # @since 5.0.0 Returns hash with values
     # @return [Hash{String => Array<Array<String, String, String>>]
@@ -292,6 +339,31 @@ module OpenC3
         time_nsec: Time.now.to_nsec_from_epoch, message: message }, scope: scope)
     end
 
+    # Deletes a limits set. The DEFAULT limits set and the currently active
+    # limits set cannot be deleted. Use set_limits_set to change the active set
+    # before deleting it. Note that the limits set is not removed from the
+    # TargetModel packet definitions; that is cleaned up on the next plugin
+    # install.
+    #
+    # @param limits_set [String] The name of the limits set to delete
+    def delete_limits_set(limits_set, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm_set', manual: manual, scope: scope, token: token)
+      limits_set = limits_set.to_s
+      raise "Cannot delete the DEFAULT limits set" if limits_set == 'DEFAULT'
+      if limits_set == LimitsEventTopic.current_set(scope: scope)
+        raise "Cannot delete the current limits set '#{limits_set}'. Use set_limits_set to change the current set first."
+      end
+      unless LimitsEventTopic.sets(scope: scope).key?(limits_set)
+        raise "Limits set '#{limits_set}' does not exist"
+      end
+
+      # Remove the limits set from Redis (limits_sets and current_limits_settings)
+      LimitsEventTopic.delete_set(limits_set, scope: scope)
+
+      message = "Deleting Limits Set: #{limits_set}"
+      Logger.info(message, scope: scope)
+    end
+
     # Returns the active limits set that applies to all telemetry
     #
     # @return [String] The current limits set

data/lib/openc3/api/tlm_api.rb

@@ -457,6 +457,12 @@ module OpenC3
     alias subscribe_packet subscribe_packets
 
     # Get packets based on ID returned from subscribe_packet.
+    # Packets are ordered within each subscribed packet stream (target/packet pair)
+    # but are NOT interleaved by time across streams. If chronological order across
+    # streams is required, sort the returned array by the 'time' field. Sorting only
+    # orders the current batch - packets across separate get_packets calls may still
+    # arrive out of order, so subscribers needing global ordering must buffer and merge
+    # across calls.
     # @param id [String] ID returned from subscribe_packets or last call to get_packets
     # @param block [Integer] Unused - Blocking must be implemented at the client
     # @param count [Integer] Maximum number of packets to return from EACH packet stream

data/lib/openc3/microservices/decom_common.rb

@@ -1,4 +1,4 @@
-# encoding: ascii-8bit
+# encoding: utf-8
 
 # Copyright 2026 OpenC3, Inc.
 # All Rights Reserved.
@@ -35,13 +35,19 @@ module OpenC3
     #   (microservice name, or "REINGEST:<job_id>").
     # @param check_limits [Boolean] When false, skips the Packet#check_limits call.
     #   Reingest passes false so historical data does not re-fire limits events.
+    # @param stored_limits_mode [String] Controls limits handling for stored packets.
+    #   'PROCESS' (default) processes limits normally.
+    #   'LOG' still evaluates limits (callback handles suppressing reactions).
+    #   'DISABLE' skips limits evaluation entirely for stored packets and omits
+    #   limits states from the decommutated output.
     # @param metric [Metric, nil] Optional; when set, records decom_duration_seconds.
     # @param error_callback [Proc, nil] Called as error_callback.call(exception) when
     #   Packet#process or Packet#check_limits raises. The microservice uses this to
     #   bump its decom_error_total metric.
     # @return [Integer] Number of (sub)packets published.
     def decom_and_publish(packet, scope:, target_names:, logger:, name:,
-                          check_limits: true, metric: nil, error_callback: nil)
+                          check_limits: true, stored_limits_mode: 'PROCESS',
+                          metric: nil, error_callback: nil)
       start = Process.clock_gettime(Process::CLOCK_MONOTONIC) if metric
       published = 0
 
@@ -62,9 +68,14 @@ module OpenC3
           logger.error e.message
         end
 
-        packet_or_subpacket.check_limits(System.limits_set) if check_limits
+        disable_stored_limits = packet_or_subpacket.stored && stored_limits_mode == 'DISABLE'
+        if check_limits && !disable_stored_limits
+          packet_or_subpacket.check_limits(System.limits_set)
+        end
 
-        TelemetryDecomTopic.write_packet(packet_or_subpacket, scope: scope)
+        TelemetryDecomTopic.write_packet(packet_or_subpacket,
+                                         include_limits_states: !disable_stored_limits,
+                                         scope: scope)
         published += 1
       end
 

data/lib/openc3/microservices/decom_microservice.rb

@@ -100,6 +100,8 @@ module OpenC3
       @limits_response_thread = nil
       System.telemetry.limits_change_callback = method(:limits_change_callback)
       LimitsEventTopic.sync_system(scope: @scope)
+      target_model = TargetModel.get_model(name: @target_names[0], scope: @scope)
+      @stored_limits_mode = target_model ? (target_model.stored_limits_mode || 'PROCESS') : 'PROCESS'
       @error_count = 0
       @metric.set(name: 'decom_total', value: @count, type: 'counter')
       @metric.set(name: 'decom_error_total', value: @error_count, type: 'counter')
@@ -184,6 +186,7 @@ module OpenC3
           logger: @logger,
           name: @name,
           check_limits: true,
+          stored_limits_mode: @stored_limits_mode,
           metric: @metric,
           error_callback: ->(e) {
             @error_count += 1
@@ -253,9 +256,11 @@ module OpenC3
       event = { type: :LIMITS_CHANGE, target_name: packet.target_name, packet_name: packet.packet_name,
                 item_name: item.name, old_limits_state: old_limits_state.to_s, new_limits_state: item.limits.state.to_s,
                 time_nsec: packet_time.to_nsec_from_epoch, message: message.to_s }
+      suppress_stored = packet.stored && @stored_limits_mode != 'PROCESS'
+      event[:suppress_stored] = true if suppress_stored
       LimitsEventTopic.write(event, scope: @scope)
 
-      if item.limits.response
+      if item.limits.response && !suppress_stored
         copied_packet = packet.deep_copy
         copied_item = packet.items[item.name]
         @limits_response_queue << [copied_packet, copied_item, old_limits_state]

data/lib/openc3/microservices/interface_microservice.rb

@@ -272,6 +272,11 @@ module OpenC3
               else
                 next nil # Don't ack disabled targets
               end
+            rescue RangeError => e
+              # Command parameter out of range is a user error, not a bug,
+              # so only log the message and not the full stack trace
+              @logger.error "#{@interface.name}: #{e.message}"
+              next e.message
             rescue => e
               @logger.error "#{@interface.name}: #{msg_hash}"
               @logger.error "#{@interface.name}: #{e.formatted}"
@@ -281,6 +286,9 @@ module OpenC3
             command.extra ||= {}
             command.extra['cmd_string'] = msg_hash['cmd_string']
             command.extra['username'] = msg_hash['username']
+            command.extra['interface_name'] = @interface.name
+            # Original author of a queued command (set when released from a queue)
+            command.extra['queue_username'] = msg_hash['queue_username'] if msg_hash['queue_username']
             # Add approver info if this was a critical command that was approved
             if critical_model
               command.extra['approver'] = critical_model.approver
@@ -706,16 +714,19 @@ module OpenC3
         # Try to do clean disconnect because we're going down
         disconnect(false)
       end
-      if @interface_or_router == 'INTERFACE'
-        InterfaceStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
-      else
-        RouterStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+      unless @cancel_thread
+        if @interface_or_router == 'INTERFACE'
+          InterfaceStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+        else
+          RouterStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+        end
       end
       @logger.info "#{@interface.name}: Stopped packet reading"
     end
 
     def handle_packet(packet)
-      InterfaceStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+      # Skip status update if stop() has been called to avoid re-creating the status model
+      InterfaceStatusModel.set(@interface.as_json(), queued: true, scope: @scope) unless @cancel_thread
       packet.received_time = Time.now.sys unless packet.received_time
 
       if packet.stored
@@ -853,7 +864,8 @@ module OpenC3
 
       # If the interface is set to auto_reconnect then delay so the thread
       # can come back around and allow the interface a chance to reconnect.
-      if allow_reconnect and @interface.auto_reconnect and @interface.state != 'DISCONNECTED'
+      # Skip reconnect if stop() has been called to avoid re-creating the status model
+      if allow_reconnect and @interface.auto_reconnect and @interface.state != 'DISCONNECTED' and !@cancel_thread
         attempting()
         if !@cancel_thread
           # @logger.debug "reconnect delay: #{@interface.reconnect_delay}"
@@ -861,10 +873,12 @@ module OpenC3
         end
       else
         @interface.state = 'DISCONNECTED'
-        if @interface_or_router == 'INTERFACE'
-          InterfaceStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
-        else
-          RouterStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+        unless @cancel_thread
+          if @interface_or_router == 'INTERFACE'
+            InterfaceStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+          else
+            RouterStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+          end
         end
       end
     end
@@ -914,4 +928,4 @@ if __FILE__ == $0
   OpenC3::InterfaceMicroservice.run
   OpenC3::ThreadManager.instance.shutdown
   OpenC3::ThreadManager.instance.join
-end
+end

data/lib/openc3/microservices/microservice.rb

@@ -155,11 +155,26 @@ module OpenC3
 
         prefix = "#{@scope}/microservices/#{@name}/"
         file_count = 0
-        client.list_objects(bucket: bucket, prefix: prefix).each do |object|
-          response_target = OpenC3.sanitize_path(File.join(@temp_dir, object.key.split(prefix)[-1]))
-          FileUtils.mkdir_p(File.dirname(response_target))
-          client.get_object(bucket: bucket, key: object.key, path: response_target)
-          file_count += 1
+        # Tolerate transient object store failures during startup. On a busy or
+        # underpowered cluster the bucket store (e.g. MinIO) can be briefly
+        # unreachable while many microservices start at once. Rather than crash
+        # and CrashLoopBackOff (which can outlast deploy timeouts), retry for a
+        # bounded time before giving up.
+        startup_timeout = (ENV['OPENC3_MICROSERVICE_STARTUP_BUCKET_TIMEOUT'] || 60).to_f
+        startup_deadline = Time.now + startup_timeout
+        begin
+          file_count = 0
+          client.list_objects(bucket: bucket, prefix: prefix).each do |object|
+            response_target = OpenC3.sanitize_path(File.join(@temp_dir, object.key.split(prefix)[-1]))
+            FileUtils.mkdir_p(File.dirname(response_target))
+            client.get_object(bucket: bucket, key: object.key, path: response_target)
+            file_count += 1
+          end
+        rescue => error
+          raise if Time.now >= startup_deadline
+          @logger.warn("Microservice #{@name} startup: bucket access failed (#{error.class}: #{error.message}); retrying for up to #{startup_timeout.to_i}s")
+          sleep(5)
+          retry
         end
 
         # Adjust @work_dir to microservice files downloaded if files and a relative path

data/lib/openc3/microservices/queue_microservice.rb

@@ -76,12 +76,14 @@ module OpenC3
               end
               validate = command.key?('validate') ? command['validate'] : true
               timeout = command['timeout']
-              cmd(command['target_name'], command['cmd_name'], cmd_params, queue: false, validate: validate, timeout: timeout, scope: @scope)
+              # Pass queue_username so Command History is attributed to the original
+              # author rather than the queue microservice name
+              cmd(command['target_name'], command['cmd_name'], cmd_params, queue: false, validate: validate, timeout: timeout, queue_username: command['username'], scope: @scope)
             elsif command['value']
               # Legacy format: use single string parameter for backwards compatibility
               validate = command.key?('validate') ? command['validate'] : true
               timeout = command['timeout']
-              cmd(command['value'], queue: false, validate: validate, timeout: timeout, scope: @scope)
+              cmd(command['value'], queue: false, validate: validate, timeout: timeout, queue_username: command['username'], scope: @scope)
             else
               @logger.error "QueueProcessor: Invalid command format, missing required fields"
             end

data/lib/openc3/migrations/20260701000000_updated_at_to_int.rb

@@ -0,0 +1,55 @@
+# encoding: ascii-8bit
+
+# Copyright 2026 OpenC3, Inc.
+# All Rights Reserved.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE.md for more details.
+#
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+require 'time'
+require 'openc3/utilities/migration'
+require 'openc3/core_ext/time'
+require 'openc3/models/scope_model'
+require 'openc3/models/script_status_model'
+
+module OpenC3
+  # Earlier versions of the Python script runner wrote the ScriptStatusModel
+  # updated_at field as an ISO8601 string (e.g. "2026-06-30T12:34:56.789012Z")
+  # instead of integer nanoseconds since the epoch. This migration rewrites any
+  # such string values as integers so updated_at is consistently an int.
+  #
+  # NOTE: The stored JSON is edited in place rather than reloaded through the
+  # model and re-created, because ScriptStatusModel#create always sets
+  # updated_at to the current time, which would discard the original timestamp.
+  class UpdatedAtToInt < Migration
+    def self.run
+      ScopeModel.names.each do |scope|
+        [ScriptStatusModel::RUNNING_PRIMARY_KEY, ScriptStatusModel::COMPLETED_PRIMARY_KEY].each do |key|
+          primary_key = "#{key}__#{scope}"
+          Store.hgetall(primary_key).each do |name, json|
+            data = JSON.parse(json, allow_nan: true)
+            updated_at = data['updated_at']
+            next unless updated_at.is_a?(String)
+
+            begin
+              data['updated_at'] = Time.parse(updated_at).to_nsec_from_epoch
+            rescue ArgumentError
+              # Leave unparsable values untouched
+              next
+            end
+            Store.hset(primary_key, name, JSON.generate(data, allow_nan: true))
+          end
+        end
+      end
+    end
+  end
+end
+
+unless ENV['OPENC3_NO_MIGRATE']
+  OpenC3::UpdatedAtToInt.run
+end

data/lib/openc3/models/cvt_model.rb

@@ -26,8 +26,8 @@ module OpenC3
     @@override_cache = {}
 
     VALUE_TYPES = [:RAW, :CONVERTED, :FORMATTED]
-    def self.build_json_from_packet(packet)
-      packet.decom
+    def self.build_json_from_packet(packet, include_limits_states: true)
+      packet.decom(include_limits_states: include_limits_states)
     end
 
     # Get a Store instance routed to the correct db_shard for a target