ace-assign 0.53.4 → 0.55.0

data/lib/ace/assign/cli/commands/step.rb

@@ -4,12 +4,12 @@ module Ace
   module Assign
     module CLI
       module Commands
-        # Print instructions for the current, next, or an explicit step.
+        # Print instructions for the focused active, next, or an explicit step.
         class Step < Ace::Support::Cli::Command
           include Ace::Support::Cli::Base
           include AssignmentTarget
 
-          desc "Show instructions for the current, next, or explicit step"
+          desc "Show instructions for the active, next, or explicit step"
 
           argument :step, required: false, desc: "Exact step number to inspect"
           option :assignment, desc: "Target specific assignment ID"
@@ -44,7 +44,7 @@ module Ace
               return step
             end
 
-            view.current_step
+            view.focus_step
           end
 
           def no_work_message(view)
@@ -52,7 +52,7 @@ module Ace
             last_done = view.scoped_state.last_done ? "#{view.scoped_state.last_done.number} #{view.scoped_state.last_done.name}" : "none"
             [
               "Assignment: #{view.assignment.id} | Status: #{state_label} | Progress: #{view.scoped_state.done.size}/#{view.scoped_state.size} done",
-              "Last done: #{last_done} | No current or next workable step"
+              "Last done: #{last_done} | No active or next workable step"
             ].join("\n")
           end
         end

data/lib/ace/assign/cli.rb

@@ -31,7 +31,7 @@ require_relative "molecules/step_writer"
 require_relative "molecules/step_renumberer"
 require_relative "molecules/skill_assign_source_resolver"
 require_relative "molecules/fork_session_launcher"
-require_relative "molecules/tmux_fork_runner"
+require_relative "molecules/tmux_control_surface_runner"
 require_relative "molecules/preset_inferrer"
 
 # Organisms

data/lib/ace/assign/models/assignment_info.rb

@@ -7,13 +7,13 @@ module Ace
       #
       # Pure data carrier with computed state (ATOM pattern).
       # Wraps an assignment with its queue state to provide
-      # computed state, progress, and current step information.
+      # computed state, progress, and active step information.
       #
       # @example
       #   info = AssignmentInfo.new(assignment: assignment, queue_state: state)
       #   info.state          # => :running
       #   info.progress       # => "2/5"
-      #   info.current_step  # => "020-implement"
+      #   info.step_focus    # => "implement"
       class AssignmentInfo
         attr_reader :assignment, :queue_state
 
@@ -39,13 +39,42 @@ module Ace
           "#{s[:done]}/#{s[:total]}"
         end
 
-        # Current step display string
+        # Active steps in queue order.
         #
-        # @return [String] Current step name or "-"
+        # @return [Array<Step>] Active steps
+        def active_steps
+          queue_state.active_steps
+        end
+
+        # Next pending workable step when nothing is active.
+        #
+        # @return [Step, nil] Next pending step or nil
+        def next_step
+          return nil unless active_steps.empty?
+
+          queue_state.next_workable
+        end
+
+        # Deterministic active step name kept for internal callers.
+        #
+        # @return [String] Focused active step name or "-"
         def current_step
           queue_state.current&.name || "-"
         end
 
+        # Human-friendly active/next summary for compact tables.
+        #
+        # @return [String] Active step names or next-step hint
+        def step_focus
+          if active_steps.any?
+            active_steps.map(&:name).join(", ")
+          elsif next_step
+            "next: #{next_step.name}"
+          else
+            "-"
+          end
+        end
+
         # Check if assignment is completed
         #
         # @return [Boolean]

data/lib/ace/assign/models/queue_state.rb

@@ -10,7 +10,7 @@ module Ace
       #
       # @example
       #   state = QueueState.new(steps: steps, assignment: assignment)
-      #   state.current  # => Step with status :in_progress
+      #   state.current  # => Deepest active step
       #   state.pending  # => Array of pending steps
       class QueueState
         attr_reader :steps, :assignment
@@ -23,16 +23,21 @@ module Ace
           @children_index = build_children_index(steps)
         end
 
-        # Get current in-progress step
-        # @return [Step, nil] Current step or nil
+        # Get the deterministic single-step active target.
+        #
+        # Returns the deepest active step in queue order. When several active
+        # branches exist globally, this is an internal convenience only; public
+        # status should use active_steps.
+        #
+        # @return [Step, nil] Deepest active step or nil
         def current
-          in_progress_steps.first
+          deepest_active
         end
 
-        # Get all in-progress steps
-        # @return [Array<Step>] In-progress steps
-        def in_progress_steps
-          steps.select { |s| s.status == :in_progress }
+        # Get all active steps in queue order.
+        # @return [Array<Step>] Active steps
+        def active_steps
+          steps.select { |s| s.status == :active }
         end
 
         # Get all pending steps
@@ -65,7 +70,7 @@ module Ace
           steps.empty?
         end
 
-        # Check if all steps are complete (no pending or in_progress)
+        # Check if all steps are complete (no pending or active)
         # @return [Boolean]
         def complete?
           steps.all?(&:complete?)
@@ -107,28 +112,28 @@ module Ace
         # - :empty     - No steps in queue
         # - :completed - All steps complete (done or failed)
         # - :failed    - Has failed step(s) but NOT all complete (stuck)
-        # - :running   - Has in_progress step with recent activity (< 1 hour)
-        # - :stalled   - Has in_progress step but stale (> 1 hour)
-        # - :paused    - Has pending but no in_progress (interrupted)
+        # - :running   - Has active step(s) with recent activity (< 1 hour)
+        # - :stalled   - Has active step(s) but all are stale (> 1 hour)
+        # - :paused    - Has pending but no active step (interrupted)
         #
         # @return [Symbol] Assignment state
         def assignment_state
           return :empty if empty?
           return :completed if complete?
           return :failed if failed.any?
-          return :running if current && recently_active?
-          return :stalled if current
+          return :running if active_steps.any? && recently_active?
+          return :stalled if active_steps.any?
 
           :paused
         end
 
-        # Check if the current in_progress step has recent activity
+        # Check if any active step has recent activity.
         # @param threshold [Integer] Seconds since started_at to consider active (default: 1 hour)
         # @return [Boolean]
         def recently_active?(threshold: 3600)
-          return false unless current&.started_at
-
-          (Time.now - current.started_at) < threshold
+          active_steps.any? do |step|
+            step.started_at && ((Time.now - step.started_at) < threshold)
+          end
         end
 
         # Summary for display
@@ -137,12 +142,19 @@ module Ace
           {
             total: size,
             done: done.size,
-            in_progress: in_progress_steps.size,
+            active: active_steps.size,
             pending: pending.size,
             failed: failed.size
           }
         end
 
+        # Get deepest active step in queue order.
+        #
+        # @return [Step, nil] Deepest active step
+        def deepest_active
+          deepest_active_from(active_steps)
+        end
+
         # Get all direct children of a step (O(1) via index)
         # @param parent_number [String] Parent step number
         # @return [Array<Step>] Direct child steps
@@ -193,21 +205,29 @@ module Ace
           subtree_steps(root_number).any? { |s| s.status == :failed }
         end
 
-        # Get the current in-progress step within a subtree.
+        # Get the deterministic active target within a subtree.
         #
         # @param root_number [String] Subtree root step number
-        # @return [Step, nil] In-progress step inside subtree, if any
+        # @return [Step, nil] Deepest active step inside subtree, if any
         def current_in_subtree(root_number)
-          in_progress_in_subtree(root_number).first
+          deepest_active_in_subtree(root_number)
         end
 
-        # Get all in-progress steps within a subtree.
+        # Get all active steps within a subtree.
         #
         # @param root_number [String] Subtree root step number
-        # @return [Array<Step>] In-progress steps inside subtree
-        def in_progress_in_subtree(root_number)
+        # @return [Array<Step>] Active steps inside subtree
+        def active_in_subtree(root_number)
           subtree_steps(root_number)
-            .select { |s| s.status == :in_progress }
+            .select { |s| s.status == :active }
+        end
+
+        # Get the deepest active step within a subtree.
+        #
+        # @param root_number [String] Subtree root step number
+        # @return [Step, nil] Deepest active step in subtree
+        def deepest_active_in_subtree(root_number)
+          deepest_active_from(active_in_subtree(root_number))
         end
 
         # Get next workable step constrained to a subtree.
@@ -215,10 +235,7 @@ module Ace
         # @param root_number [String] Subtree root step number
         # @return [Step, nil] Next pending workable step inside subtree
         def next_workable_in_subtree(root_number)
-          subtree_steps(root_number)
-            .select { |s| s.status == :pending }
-            .reject { |s| has_incomplete_children?(s.number) }
-            .first
+          next_workable(scope_root: root_number)
         end
 
         # Build ancestor chain from closest parent to root.
@@ -260,19 +277,41 @@ module Ace
           children_of(parent_number).any? { |s| s.status != :done }
         end
 
-        # Get next workable step considering hierarchy.
+        # Get next workable pending step considering hierarchy and active fork ownership.
         # A step is workable if it's pending and has no incomplete children.
-        # Prefers children of current/recent work.
+        #
+        # Pending descendants under an active fork root are hidden unless the caller
+        # is explicitly scoped inside that root.
+        #
+        # @param scope_root [String, nil] Optional subtree scope
         # @return [Step, nil] Next step to work on
-        def next_workable
-          # First, find pending steps
-          pending_steps = pending
+        def next_workable(scope_root: nil)
+          candidate_steps = scope_root ? subtree_steps(scope_root) : steps
+          candidate_steps
+            .select { |s| s.status == :pending }
+            .reject { |s| has_incomplete_children?(s.number) && !runnable_delegation_parent?(s, scope_root: scope_root) }
+            .reject { |s| hidden_by_active_fork_root?(s.number, scope_root: scope_root) }
+            .first
+        end
 
-          # Filter to steps that don't have incomplete children
-          workable = pending_steps.reject { |s| has_incomplete_children?(s.number) }
+        # Get active fork roots in queue order.
+        #
+        # @return [Array<Step>] Active fork-scoped steps
+        def active_fork_roots
+          active_steps.select(&:fork?)
+        end
 
-          # Return first workable step (already sorted by number)
-          workable.first
+        # Check whether active steps inside a subtree fan out across more than one branch.
+        #
+        # @param root_number [String] Subtree root step number
+        # @param extra_active [Array<String>] Additional active step numbers to include
+        # @return [Boolean] True when active steps inside the subtree are not on a single path
+        def active_branch_conflict_in_subtree?(root_number, extra_active: [])
+          active_numbers = active_in_subtree(root_number).map(&:number) + Array(extra_active).map(&:to_s)
+          unique_active = active_numbers.uniq
+          unique_active.combination(2).any? do |left, right|
+            !(in_subtree?(left, right) || in_subtree?(right, left))
+          end
         end
 
         # Get all step numbers as an array
@@ -295,6 +334,12 @@ module Ace
 
         private
 
+        def runnable_delegation_parent?(step, scope_root:)
+          return false unless scope_root.nil? || scope_root.to_s.strip.empty?
+
+          step.batch_parent == true || step.fork?
+        end
+
         # Build index of children by parent number for O(1) lookups
         # @param steps [Array<Step>] All steps
         # @return [Hash<String, Array<Step>>] Parent number => children mapping
@@ -321,6 +366,23 @@ module Ace
             }
           end
         end
+
+        def deepest_active_from(active)
+          return nil if active.empty?
+
+          max_depth = active.map { |step| step.number.to_s.split(".").length }.max
+          active.find { |step| step.number.to_s.split(".").length == max_depth }
+        end
+
+        def hidden_by_active_fork_root?(step_number, scope_root:)
+          active_fork_roots.any? do |root|
+            next false if step_number == root.number
+            next false unless in_subtree?(root.number, step_number)
+            next false if scope_root && in_subtree?(root.number, scope_root)
+
+            true
+          end
+        end
       end
     end
   end

data/lib/ace/assign/models/step.rb

@@ -17,7 +17,7 @@ module Ace
       #   )
       class Step
         # Valid status values
-        STATUSES = %i[pending in_progress done failed].freeze
+        STATUSES = %i[pending active done failed].freeze
 
         # Valid context values for execution context
         VALID_CONTEXTS = %w[fork].freeze
@@ -31,7 +31,7 @@ module Ace
 
         # @param number [String] Step number (e.g., "010", "010.01")
         # @param name [String] Step name
-        # @param status [Symbol] Step status (:pending, :in_progress, :done, :failed)
+        # @param status [Symbol] Step status (:pending, :active, :done, :failed)
         # @param instructions [String] Step instructions (markdown)
         # @param report [String, nil] Completion report content
         # @param error [String, nil] Error message (if failed)
@@ -103,7 +103,7 @@ module Ace
         # Check if step can be worked on
         # @return [Boolean]
         def workable?
-          status == :pending || status == :in_progress
+          status == :pending || status == :active
         end
 
         # Check if this is a retry of another step
@@ -128,6 +128,16 @@ module Ace
           provider.empty? ? nil : provider
         end
 
+        # Resolve per-step launch-mode override from fork options.
+        # @return [String, nil]
+        def fork_mode
+          return nil unless fork_options
+
+          mode = fork_options["mode"]
+          mode = mode.to_s.strip
+          mode.empty? ? nil : mode
+        end
+
         # Get the original step number if this is a retry
         # @return [String, nil] Original step number
         def retry_of

data/lib/ace/assign/molecules/fork_session_launcher.rb

@@ -2,8 +2,6 @@
 
 require "ace/llm"
 require "fileutils"
-require "rbconfig"
-require "shellwords"
 
 module Ace
   module Assign
@@ -15,25 +13,37 @@ module Ace
         DEFAULT_LAUNCH_MODE = "auto"
         VALID_LAUNCH_MODES = %w[auto headless tmux].freeze
         TMUX_POLL_INTERVAL = 0.5
+        DEFAULT_TARGET_ENV = "ACE_ASSIGN_DEFAULT_TARGET"
+        CURRENT_ASSIGNMENT_ID_ENV = "ACE_ASSIGN_CURRENT_ASSIGNMENT_ID"
+        CURRENT_FORK_ROOT_ENV = "ACE_ASSIGN_CURRENT_FORK_ROOT"
+
+        def self.fork_scope_env(assignment_id:, fork_root:)
+          scoped_target = "#{assignment_id}@#{fork_root}"
+          {
+            DEFAULT_TARGET_ENV => scoped_target,
+            CURRENT_ASSIGNMENT_ID_ENV => assignment_id.to_s,
+            CURRENT_FORK_ROOT_ENV => fork_root.to_s
+          }
+        end
+
+        def self.same_scoped_refork?(assignment_id:, fork_root:, env: ENV)
+          assignment_ref = assignment_id.to_s.strip
+          root_ref = fork_root.to_s.strip
+          return false if assignment_ref.empty? || root_ref.empty?
+
+          env[CURRENT_ASSIGNMENT_ID_ENV].to_s.strip == assignment_ref &&
+            env[CURRENT_FORK_ROOT_ENV].to_s.strip == root_ref
+        end
 
         def initialize(config: nil, query_interface: Ace::LLM::QueryInterface, tmux_runner: nil, interactive_builder: nil)
           @config = config || Ace::Assign.config
           @query_interface = query_interface
-          @tmux_runner = tmux_runner || TmuxForkRunner.new
+          @tmux_runner = tmux_runner || TmuxControlSurfaceRunner.new
           @interactive_builder = interactive_builder || Ace::LLM::Molecules::InteractiveCommandBuilder.new
         end
 
-        # Launch forked subtree execution synchronously.
-        #
-        # @param assignment_id [String] Assignment identifier
-        # @param fork_root [String] Subtree root step number
-        # @param provider [String, nil] Optional provider override
-        # @param cli_args [String, nil] Optional provider CLI args
-        # @param timeout [Integer, nil] Optional timeout override (seconds)
-        # @param cache_dir [String, nil] Assignment cache directory for last-message capture
-        # @param launch_mode [String, nil] Launch mode override (auto|headless|tmux)
-        # @return [Hash] QueryInterface response
-        def launch(assignment_id:, fork_root:, provider: nil, cli_args: nil, timeout: nil, cache_dir: nil, launch_mode: nil)
+        def launch(assignment_id:, fork_root:, provider: nil, cli_args: nil, timeout: nil, cache_dir: nil, launch_mode: nil, callback_pane: nil)
+          ensure_not_same_scoped_refork!(assignment_id: assignment_id, fork_root: fork_root)
           resolved_provider = provider || config.dig("execution", "provider") || DEFAULT_PROVIDER
           resolved_timeout = timeout || config.dig("execution", "timeout") || DEFAULT_TIMEOUT
           resolved_mode = resolve_launch_mode(launch_mode)
@@ -45,7 +55,8 @@ module Ace
               provider: resolved_provider,
               cli_args: cli_args,
               timeout: resolved_timeout,
-              cache_dir: cache_dir
+              cache_dir: cache_dir,
+              callback_pane: callback_pane
             )
           else
             launch_provider_session(
@@ -59,13 +70,19 @@ module Ace
           end
         end
 
+        def callback_pane
+          tmux_runner.current_pane
+        end
+
         def launch_provider_session(assignment_id:, fork_root:, provider:, cli_args: nil, timeout: nil, cache_dir: nil,
           last_message_file: nil, session_meta_file: nil)
+          ensure_not_same_scoped_refork!(assignment_id: assignment_id, fork_root: fork_root)
           resolved_provider = provider || config.dig("execution", "provider") || DEFAULT_PROVIDER
           resolved_timeout = timeout || config.dig("execution", "timeout") || DEFAULT_TIMEOUT
           scoped_assignment = "#{assignment_id}@#{fork_root}"
           prompt = "/as-assign-drive #{scoped_assignment}"
           last_msg_file = last_message_file || build_last_message_file(cache_dir, fork_root)
+          scope_env = self.class.fork_scope_env(assignment_id: assignment_id, fork_root: fork_root)
 
           result = query_interface.query(
             resolved_provider,
@@ -74,12 +91,10 @@ module Ace
             cli_args: cli_args,
             timeout: resolved_timeout,
             fallback: false,
-            last_message_file: last_msg_file
+            last_message_file: last_msg_file,
+            subprocess_env: scope_env
           )
 
-          # Layer 1 write: capture last message for non-Codex providers (or when Codex didn't write).
-          # Safety: `query` blocks until the subprocess exits, so by this point Layer 2 (Codex
-          # --output-last-message) has already finished writing. No other writer exists at this point.
           if last_msg_file && result[:text] && !result[:text].strip.empty?
             existing = File.exist?(last_msg_file) ? File.read(last_msg_file).strip : ""
             File.write(last_msg_file, result[:text]) if existing.empty?
@@ -98,6 +113,7 @@ module Ace
 
         def resolve_launch_mode(explicit_mode)
           mode = explicit_mode.to_s.strip
+          mode = config.dig("execution", "launch_mode").to_s.strip if mode.empty?
           mode = DEFAULT_LAUNCH_MODE if mode.empty?
           unless VALID_LAUNCH_MODES.include?(mode)
             raise Error, "Invalid launch mode '#{mode}'. Expected one of: #{VALID_LAUNCH_MODES.join(', ')}"
@@ -108,7 +124,8 @@ module Ace
           tmux_runner.tmux_context? ? "tmux" : "headless"
         end
 
-        def launch_tmux(assignment_id:, fork_root:, provider:, cli_args:, timeout:, cache_dir:)
+        def launch_tmux(assignment_id:, fork_root:, provider:, cli_args:, timeout:, cache_dir:, callback_pane: nil)
+          ensure_not_same_scoped_refork!(assignment_id: assignment_id, fork_root: fork_root)
           session = tmux_runner.current_session
           raise Error, "Launch mode tmux requires an active tmux session (TMUX or ACE_TMUX_SESSION)." unless session
           raise Error, "Tmux launch requires assignment cache_dir for subtree polling." if cache_dir.to_s.strip.empty?
@@ -123,31 +140,35 @@ module Ace
           pane_target = tmux_runner.prepare_pane(
             session: session,
             window: fork_window,
+            window_target: window_info[:target],
             root: Dir.pwd,
             keep_existing: window_info[:created]
           )
 
           session_meta_file = build_session_meta_file(cache_dir, fork_root)
           prompt = "/as-assign-drive #{assignment_id}@#{fork_root}"
-          invocation = interactive_builder.build(
-            provider_model: provider,
-            prompt: prompt,
-            cli_args: cli_args
-          )
-          script_path = build_tmux_wrapper(
+          tmux_env = tmux_subprocess_env(
             assignment_id: assignment_id,
             fork_root: fork_root,
-            provider: provider,
-            cli_args: cli_args,
-            timeout: timeout,
-            session_meta_file: session_meta_file,
             session: session,
             fork_window: fork_window,
-            visible_handoff: invocation[:prompt]
+            callback_pane: callback_pane
+          )
+          invocation = interactive_builder.build(
+            provider_model: provider,
+            prompt: prompt,
+            cli_args: cli_args,
+            working_dir: Dir.pwd,
+            subprocess_env: tmux_env
           )
 
-          tmux_runner.run_script_in_pane(pane_target: pane_target, script_path: script_path)
-          tmux_runner.select_window(session: session, window: fork_window) if window_info[:created] && current_window != fork_window
+          tmux_runner.run_invocation_in_pane(
+            pane_target: pane_target,
+            command: invocation[:command],
+            env: invocation[:env],
+            working_dir: invocation[:working_dir],
+            visible_handoff: invocation[:prompt]
+          )
           write_tmux_launch_metadata(
             session_meta_file: session_meta_file,
             provider: invocation[:provider],
@@ -158,8 +179,13 @@ module Ace
             session_meta_file: session_meta_file,
             session: session,
             window: fork_window,
-            pane: pane_target
+            pane: pane_target,
+            window_id: window_info[:window_id],
+            callback_pane: callback_pane
           )
+
+          return {tmux: true, pane_target: pane_target, callback_mode: true, callback_pane: callback_pane} if callback_pane
+
           wait_for_subtree_terminal(
             assignment_id: assignment_id,
             fork_root: fork_root,
@@ -226,32 +252,22 @@ module Ace
           File.join(sessions_dir, "#{fork_root}-session.yml")
         end
 
-        def build_tmux_wrapper(assignment_id:, fork_root:, provider:, cli_args:, timeout:, session_meta_file:, session:, fork_window:, visible_handoff:)
-          sessions_dir = File.dirname(session_meta_file)
-          FileUtils.mkdir_p(sessions_dir)
-          script_path = File.join(sessions_dir, "#{fork_root}-tmux-launch.sh")
-
-          command = [
-            "ace-llm", provider, "/as-assign-drive #{assignment_id}@#{fork_root}",
-            "--interactive"
-          ]
-          command.concat(["--cli-args", cli_args]) if cli_args && !cli_args.strip.empty?
-
-          script = <<~BASH
-            #!/usr/bin/env bash
-            set -uo pipefail
-            cd #{Shellwords.escape(Dir.pwd)}
-            export PROJECT_ROOT_PATH=#{Shellwords.escape(Dir.pwd)}
-            export ACE_TMUX_SESSION=#{Shellwords.escape(session)}
-            export ACE_ASSIGN_LAUNCH_MODE=tmux
-            export ACE_ASSIGN_FORK_WINDOW=#{Shellwords.escape(fork_window)}
-            printf '%s\n' #{Shellwords.escape(visible_handoff.to_s)}
-            exec #{command.map { |part| Shellwords.escape(part) }.join(" ")}
-          BASH
-
-          File.write(script_path, script)
-          FileUtils.chmod(0o755, script_path)
-          script_path
+        def ensure_not_same_scoped_refork!(assignment_id:, fork_root:)
+          return unless self.class.same_scoped_refork?(assignment_id: assignment_id, fork_root: fork_root)
+
+          raise Error,
+            "Cannot fork-run subtree #{assignment_id}@#{fork_root}: already running inside that scoped subtree. Continue inline instead of calling fork-run again."
+        end
+
+        def tmux_subprocess_env(assignment_id:, fork_root:, session:, fork_window:, callback_pane: nil)
+          env = self.class.fork_scope_env(assignment_id: assignment_id, fork_root: fork_root).merge(
+            "PROJECT_ROOT_PATH" => Dir.pwd,
+            "ACE_TMUX_SESSION" => session,
+            "ACE_ASSIGN_LAUNCH_MODE" => "tmux",
+            "ACE_ASSIGN_FORK_WINDOW" => fork_window
+          )
+          env["ACE_ASSIGN_CALLBACK_PANE"] = callback_pane if callback_pane && !callback_pane.empty?
+          env
         end
 
         def wait_for_subtree_terminal(assignment_id:, fork_root:, cache_dir:, timeout:)

data/lib/ace/assign/molecules/step_writer.rb

@@ -59,13 +59,13 @@ module Ace
           file_path
         end
 
-        # Mark step as in progress
+        # Mark step as active
         #
         # @param file_path [String] Path to step file
         # @return [String] Updated file path
-        def mark_in_progress(file_path)
+        def mark_active(file_path)
           update_frontmatter(file_path, {
-            "status" => "in_progress",
+            "status" => "active",
             "started_at" => Time.now.utc.iso8601
           })
         end