ariadna 1.3.0 → 2.0.0

data/lib/ariadna/tools/state_manager.rb

@@ -1,465 +1,199 @@
 require "json"
 require_relative "output"
-require_relative "config_manager"
 require_relative "frontmatter"
 
 module Ariadna
   module Tools
-    module StateManager
-      def self.dispatch(argv, raw: false)
-        subcommand = argv.shift
+    # Memory-directory-based state management using Memory Tool verbs.
+    module StateManager # rubocop:disable Metrics/ModuleLength
+      MEMORY_DIR = ".ariadna_planning/memory".freeze
+
+      def self.dispatch(args, raw: false) # rubocop:disable Metrics/CyclomaticComplexity
+        subcommand = args.shift
         case subcommand
-        when "load"
-          load_state(raw: raw)
-        when "get"
-          get(argv.first, raw: raw)
-        when "update"
-          update(argv[0], argv[1], raw: raw)
-        when "patch"
-          patches = parse_patches(argv)
-          patch(patches, raw: raw)
-        when "advance-plan"
-          advance_plan(raw: raw)
-        when "record-metric"
-          options = parse_named_args(argv, %w[phase plan duration tasks files])
-          record_metric(options, raw: raw)
-        when "update-progress"
-          update_progress(raw: raw)
-        when "add-decision"
-          options = parse_named_args(argv, %w[phase summary rationale])
-          add_decision(options, raw: raw)
-        when "add-blocker"
-          text = extract_flag(argv, "--text") || argv.first
-          add_blocker(text, raw: raw)
-        when "resolve-blocker"
-          text = extract_flag(argv, "--text") || argv.first
-          resolve_blocker(text, raw: raw)
-        when "record-session"
-          options = parse_named_args(argv, %w[stopped-at resume-file])
-          record_session(options, raw: raw)
-        else
-          Output.error("Unknown state subcommand: #{subcommand}")
-        end
+        when "list" then list_memory(args, raw: raw)
+        when "view" then view(args, raw: raw)
+        when "create" then create(args, raw: raw)
+        when "update" then update(args, raw: raw)
+        when "insert" then insert(args, raw: raw)
+        when "delete" then delete_file(args, raw: raw)
+        when "add-decision" then add_decision(args, raw: raw)
+        when "add-blocker" then add_blocker(args, raw: raw)
+        when "resolve-blocker" then resolve_blocker(args, raw: raw)
+        when "record-metric" then record_metric(args, raw: raw)
+        when "record-session" then record_session(args, raw: raw)
+        when "history-digest" then history_digest(args, raw: raw)
+        else Output.error("Unknown state subcommand: #{subcommand}")
+        end
+      end
+
+      def self.list_memory(_args, raw: false)
+        dir = memory_path
+        FileUtils.mkdir_p(dir)
+        files = Dir.children(dir).sort.map do |name|
+          { name: name, size: File.stat(File.join(dir, name)).size }
+        end
+        Output.json({ files: files }, raw: raw)
+      end
+
+      def self.view(args, raw: false)
+        filename = args.shift
+        Output.error("filename required") unless filename
+        path = safe_path!(filename)
+        Output.error("File not found: #{filename}") unless File.exist?(path)
+        content = File.read(path)
+        Output.json({ file: filename, content: content, lines: content.lines.count }, raw: raw)
+      end
+
+      def self.create(args, raw: false)
+        filename = args.shift
+        content = args.shift || ""
+        Output.error("filename required") unless filename
+        path = safe_path!(filename)
+        Output.error("File already exists: #{filename}") if File.exist?(path)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, content)
+        Output.json({ created: true, file: filename }, raw: raw)
+      end
+
+      def self.update(args, raw: false)
+        filename, old_str, new_str = args.shift(3)
+        Output.error("filename, old_str, and new_str required") unless filename && old_str && new_str
+        path = safe_path!(filename)
+        Output.error("File not found: #{filename}") unless File.exist?(path)
+        content = File.read(path)
+        count = content.scan(old_str).length
+        Output.error("old_str not found in #{filename}") if count.zero?
+        Output.error("old_str is ambiguous (#{count} occurrences) in #{filename}") if count > 1
+        File.write(path, content.sub(old_str, new_str))
+        Output.json({ updated: true, file: filename }, raw: raw)
+      end
+
+      def self.insert(args, raw: false)
+        filename = args.shift
+        line_num = args.shift&.to_i
+        text = args.shift
+        Output.error("filename, line_number, and text required") unless filename && line_num && text
+        path = safe_path!(filename)
+        Output.error("File not found: #{filename}") unless File.exist?(path)
+        lines = File.readlines(path)
+        lines.insert([line_num - 1, 0].max, "#{text}\n")
+        File.write(path, lines.join)
+        Output.json({ inserted: true, file: filename, at_line: line_num }, raw: raw)
+      end
+
+      def self.delete_file(args, raw: false)
+        filename = args.shift
+        Output.error("filename required") unless filename
+        path = safe_path!(filename)
+        Output.error("File not found: #{filename}") unless File.exist?(path)
+        File.delete(path)
+        Output.json({ deleted: true, file: filename }, raw: raw)
+      end
+
+      def self.add_decision(args, raw: false)
+        opts = parse_named_args(args, %w[phase summary rationale])
+        summary = opts["summary"]
+        Output.error("--summary required") unless summary
+        phase = opts["phase"] || "?"
+        suffix = opts["rationale"] ? " -- #{opts['rationale']}" : ""
+        entry = "- [Phase #{phase}]: #{summary}#{suffix}"
+        append_to_memory_file("decisions.md", "# Decisions", entry)
+        Output.json({ added: true, decision: entry }, raw: raw)
+      end
+
+      def self.add_blocker(args, raw: false)
+        text = extract_flag(args, "--text") || args.first
+        Output.error("--text required") unless text
+        append_to_memory_file("blockers.md", "# Blockers", "- #{text}")
+        Output.json({ added: true, blocker: text }, raw: raw)
+      end
+
+      def self.resolve_blocker(args, raw: false)
+        text = extract_flag(args, "--text") || args.first
+        Output.error("--text required") unless text
+        path = File.join(memory_path, "blockers.md")
+        Output.error("blockers.md not found") unless File.exist?(path)
+        lines = File.read(path).split("\n")
+        filtered = lines.reject { |l| l.start_with?("- ") && l.downcase.include?(text.downcase) }
+        File.write(path, "#{filtered.join("\n")}\n")
+        Output.json({ resolved: true, blocker: text }, raw: raw)
+      end
+
+      def self.record_metric(args, raw: false)
+        opts = parse_named_args(args, %w[phase plan duration tasks files])
+        phase, plan, duration = opts.values_at("phase", "plan", "duration")
+        Output.error("--phase, --plan, and --duration required") unless phase && plan && duration
+        tasks = opts["tasks"] || "-"
+        files = opts["files"] || "-"
+        entry = "| Phase #{phase} P#{plan} | #{duration} | #{tasks} tasks | #{files} files |"
+        append_to_memory_file("metrics.md", "# Metrics", entry)
+        Output.json({ recorded: true, phase: phase, plan: plan, duration: duration }, raw: raw)
+      end
+
+      def self.record_session(args, raw: false)
+        opts = parse_named_args(args, %w[stopped-at resume-file])
+        now = Time.now.utc.iso8601
+        lines = ["# Session", "", "**Last session:** #{now}"]
+        lines << "**Stopped at:** #{opts['stopped-at']}" if opts["stopped-at"]
+        lines << "**Resume file:** #{opts['resume-file']}" if opts["resume-file"]
+        path = File.join(memory_path, "session.md")
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, "#{lines.join("\n")}\n")
+        Output.json({ recorded: true, timestamp: now }, raw: raw)
       end
 
-      def self.history_digest(_argv, raw: false)
-        cwd = Dir.pwd
-        phases_dir = File.join(cwd, ".ariadna_planning", "phases")
-        digest = { phases: {}, decisions: [], tech_stack: [] }
+      def self.history_digest(_args, raw: false)
+        phases_dir = File.join(Dir.pwd, ".ariadna_planning", "phases")
+        lines = ["# History Digest", ""]
+        collect_phase_summaries(phases_dir, lines) if File.directory?(phases_dir)
+        path = File.join(memory_path, "history.md")
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, "#{lines.join("\n")}\n")
+        Output.json({ created: true, file: "history.md" }, raw: raw)
+      end
 
-        unless File.directory?(phases_dir)
-          Output.json(digest, raw: raw)
-          return
-        end
+      # --- Private helpers ---
 
-        tech_stack_set = []
+      def self.collect_phase_summaries(phases_dir, lines) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         Dir.children(phases_dir).sort.each do |dir|
           dir_path = File.join(phases_dir, dir)
           next unless File.directory?(dir_path)
 
-          summaries = Dir.children(dir_path).select { |f| f.end_with?("-SUMMARY.md", "SUMMARY.md") }
-          summaries.each do |summary|
-            content = File.read(File.join(dir_path, summary))
-            fm = Frontmatter.extract(content)
-
-            phase_num = fm["phase"] || dir.split("-").first
-            digest[:phases][phase_num] ||= { name: dir.split("-")[1..].join(" ") || "Unknown", provides: [], affects: [], patterns: [] }
-
-            dep_graph = fm["dependency-graph"] || {}
-            (dep_graph["provides"] || fm["provides"] || []).each { |p| digest[:phases][phase_num][:provides] << p }
-            (dep_graph["affects"] || []).each { |a| digest[:phases][phase_num][:affects] << a }
-            (fm["patterns-established"] || []).each { |p| digest[:phases][phase_num][:patterns] << p }
-            (fm["key-decisions"] || []).each { |d| digest[:decisions] << { phase: phase_num, decision: d } }
-
-            tech = fm["tech-stack"]
-            (tech["added"] || []).each { |t| tech_stack_set << (t.is_a?(String) ? t : t["name"]) } if tech.is_a?(Hash)
+          lines << "## #{dir}"
+          Dir.children(dir_path).select { |f| f.end_with?("SUMMARY.md") }.sort.each do |s|
+            fm = Frontmatter.extract(File.read(File.join(dir_path, s)))
+            lines << "- **#{s}**: #{(fm['provides'] || []).join(', ')}"
+            (fm["key-decisions"] || []).each { |d| lines << "  - Decision: #{d}" }
           rescue StandardError
             next
           end
+          lines << ""
         end
-
-        digest[:phases].each_value do |p|
-          p[:provides].uniq!
-          p[:affects].uniq!
-          p[:patterns].uniq!
-        end
-        digest[:tech_stack] = tech_stack_set.uniq
-
-        Output.json(digest, raw: raw)
-      end
-
-      def self.summary_extract(argv, raw: false)
-        path = argv.shift
-        Output.error("path required") unless path
-        fields_idx = argv.index("--fields")
-        fields = fields_idx ? argv[fields_idx + 1]&.split(",") : nil
-
-        cwd = Dir.pwd
-        full_path = File.expand_path(path, cwd)
-        content = File.read(full_path)
-        fm = Frontmatter.extract(content)
-
-        result = fields ? fm.slice(*fields) : fm
-        Output.json(result, raw: raw)
-      rescue Errno::ENOENT
-        Output.error("File not found: #{path}")
-      end
-
-      def self.snapshot(_argv, raw: false)
-        cwd = Dir.pwd
-        state_path = File.join(cwd, ".ariadna_planning", "STATE.md")
-        Output.error("STATE.md not found") unless File.exist?(state_path)
-
-        content = File.read(state_path)
-        fields = {}
-        content.scan(/\*\*(.+?):\*\*\s*(.+)/) { |k, v| fields[k.strip] = v.strip }
-
-        Output.json(fields, raw: raw)
-      end
-
-      # --- Core state operations ---
-
-      def self.load_state(raw: false)
-        cwd = Dir.pwd
-        config = ConfigManager.load_config(cwd)
-        planning_dir = File.join(cwd, ".ariadna_planning")
-
-        state_raw = begin
-          File.read(File.join(planning_dir, "STATE.md"))
-        rescue Errno::ENOENT
-          ""
-        end
-
-        result = {
-          config: config,
-          state_raw: state_raw,
-          state_exists: !state_raw.empty?,
-          roadmap_exists: File.exist?(File.join(planning_dir, "ROADMAP.md")),
-          config_exists: File.exist?(File.join(planning_dir, "config.json"))
-        }
-
-        if raw
-          lines = config.map { |k, v| "#{k}=#{v}" }
-          lines << "config_exists=#{result[:config_exists]}"
-          lines << "roadmap_exists=#{result[:roadmap_exists]}"
-          lines << "state_exists=#{result[:state_exists]}"
-          $stdout.write(lines.join("\n"))
-          exit 0
-        end
-
-        Output.json(result)
-      end
-
-      def self.get(section, raw: false)
-        cwd = Dir.pwd
-        state_path = File.join(cwd, ".ariadna_planning", "STATE.md")
-        content = File.read(state_path)
-
-        unless section
-          Output.json({ content: content }, raw: raw, raw_value: content)
-          return
-        end
-
-        escaped = Regexp.escape(section)
-
-        # Check for **field:** value
-        if (match = content.match(/\*\*#{escaped}:\*\*\s*(.*)/i))
-          Output.json({ section => match[1].strip }, raw: raw, raw_value: match[1].strip)
-          return
-        end
-
-        # Check for ## Section
-        if (match = content.match(/##\s*#{escaped}\s*\n([\s\S]*?)(?=\n##|$)/i))
-          Output.json({ section => match[1].strip }, raw: raw, raw_value: match[1].strip)
-          return
-        end
-
-        Output.json({ error: "Section or field \"#{section}\" not found" }, raw: raw, raw_value: "")
-      rescue Errno::ENOENT
-        Output.error("STATE.md not found")
       end
 
-      def self.update(field, value, raw: false)
-        Output.error("field and value required for state update") unless field && value
-
-        cwd = Dir.pwd
-        state_path = File.join(cwd, ".ariadna_planning", "STATE.md")
-        content = File.read(state_path)
-
-        new_content = replace_field(content, field, value)
-        if new_content
-          File.write(state_path, new_content)
-          Output.json({ updated: true })
-        else
-          Output.json({ updated: false, reason: "Field \"#{field}\" not found in STATE.md" })
-        end
-      rescue Errno::ENOENT
-        Output.json({ updated: false, reason: "STATE.md not found" })
+      def self.memory_path
+        File.join(Dir.pwd, MEMORY_DIR)
       end
 
-      def self.patch(patches, raw: false)
-        cwd = Dir.pwd
-        state_path = File.join(cwd, ".ariadna_planning", "STATE.md")
-        content = File.read(state_path)
-
-        results = { updated: [], failed: [] }
-        patches.each do |field, value|
-          new_content = replace_field(content, field, value)
-          if new_content
-            content = new_content
-            results[:updated] << field
-          else
-            results[:failed] << field
-          end
-        end
-
-        File.write(state_path, content) unless results[:updated].empty?
-        Output.json(results, raw: raw, raw_value: results[:updated].empty? ? "false" : "true")
-      rescue Errno::ENOENT
-        Output.error("STATE.md not found")
+      def self.safe_path!(filename)
+        dir = memory_path
+        resolved = File.expand_path(filename, dir)
+        Output.error("Path outside memory directory: #{filename}") unless resolved.start_with?(File.expand_path(dir))
+        resolved
       end
 
-      def self.advance_plan(raw: false)
-        cwd = Dir.pwd
-        state_path = File.join(cwd, ".ariadna_planning", "STATE.md")
-        unless File.exist?(state_path)
-          Output.json({ error: "STATE.md not found" }, raw: raw)
-          return
-        end
-
-        content = File.read(state_path)
-        current_plan = extract_field(content, "Current Plan")&.to_i
-        total_plans = extract_field(content, "Total Plans in Phase")&.to_i
-        today = Time.now.utc.strftime("%Y-%m-%d")
-
-        unless current_plan && total_plans
-          Output.json({ error: "Cannot parse Current Plan or Total Plans in Phase from STATE.md" }, raw: raw)
-          return
-        end
-
-        if current_plan >= total_plans
-          content = replace_field(content, "Status", "Phase complete — ready for verification") || content
-          content = replace_field(content, "Last Activity", today) || content
-          File.write(state_path, content)
-          Output.json({ advanced: false, reason: "last_plan", current_plan: current_plan, total_plans: total_plans }, raw: raw, raw_value: "false")
+      def self.append_to_memory_file(filename, header, entry)
+        dir = memory_path
+        FileUtils.mkdir_p(dir)
+        path = File.join(dir, filename)
+        if File.exist?(path)
+          File.write(path, "#{File.read(path).rstrip}\n#{entry}\n")
         else
-          new_plan = current_plan + 1
-          content = replace_field(content, "Current Plan", new_plan.to_s) || content
-          content = replace_field(content, "Status", "Ready to execute") || content
-          content = replace_field(content, "Last Activity", today) || content
-          File.write(state_path, content)
-          Output.json({ advanced: true, previous_plan: current_plan, current_plan: new_plan, total_plans: total_plans }, raw: raw, raw_value: "true")
+          File.write(path, "#{header}\n\n#{entry}\n")
         end
       end
 
-      def self.record_metric(options, raw: false)
-        cwd = Dir.pwd
-        state_path = File.join(cwd, ".ariadna_planning", "STATE.md")
-        unless File.exist?(state_path)
-          Output.json({ error: "STATE.md not found" }, raw: raw)
-          return
-        end
-
-        phase = options["phase"]
-        plan = options["plan"]
-        duration = options["duration"]
-        Output.error("phase, plan, and duration required") unless phase && plan && duration
-
-        content = File.read(state_path)
-        new_row = "| Phase #{phase} P#{plan} | #{duration} | #{options['tasks'] || '-'} tasks | #{options['files'] || '-'} files |"
-
-        pattern = /(##\s*Performance Metrics[\s\S]*?\n\|[^\n]+\n\|[-|\s]+\n)([\s\S]*?)(?=\n##|\n$|\z)/i
-        if (match = content.match(pattern))
-          body = match[2].rstrip
-          body = body.strip.empty? || body.include?("None yet") ? new_row : "#{body}\n#{new_row}"
-          content = content.sub(pattern, "#{match[1]}#{body}\n")
-          File.write(state_path, content)
-          Output.json({ recorded: true, phase: phase, plan: plan, duration: duration }, raw: raw, raw_value: "true")
-        else
-          Output.json({ recorded: false, reason: "Performance Metrics section not found" }, raw: raw, raw_value: "false")
-        end
-      end
-
-      def self.update_progress(raw: false)
-        cwd = Dir.pwd
-        state_path = File.join(cwd, ".ariadna_planning", "STATE.md")
-        unless File.exist?(state_path)
-          Output.json({ error: "STATE.md not found" }, raw: raw)
-          return
-        end
-
-        content = File.read(state_path)
-        phases_dir = File.join(cwd, ".ariadna_planning", "phases")
-        total_plans = 0
-        total_summaries = 0
-
-        if File.directory?(phases_dir)
-          Dir.children(phases_dir).each do |dir|
-            dir_path = File.join(phases_dir, dir)
-            next unless File.directory?(dir_path)
-
-            files = Dir.children(dir_path)
-            total_plans += files.count { |f| f.match?(/-PLAN\.md$/i) }
-            total_summaries += files.count { |f| f.match?(/-SUMMARY\.md$/i) }
-          end
-        end
-
-        percent = total_plans > 0 ? (total_summaries.to_f / total_plans * 100).round : 0
-        bar_width = 10
-        filled = (percent.to_f / 100 * bar_width).round
-        bar = "\u2588" * filled + "\u2591" * (bar_width - filled)
-        progress_str = "[#{bar}] #{percent}%"
-
-        if content.match?(/\*\*Progress:\*\*/i) || content.match?(/^Progress:/i)
-          content = content.sub(/(Progress:\s*).*/i, "\\1#{progress_str}")
-          File.write(state_path, content)
-          Output.json({ updated: true, percent: percent, completed: total_summaries, total: total_plans, bar: progress_str }, raw: raw, raw_value: progress_str)
-        else
-          Output.json({ updated: false, reason: "Progress field not found" }, raw: raw, raw_value: "false")
-        end
-      end
-
-      def self.add_decision(options, raw: false)
-        cwd = Dir.pwd
-        state_path = File.join(cwd, ".ariadna_planning", "STATE.md")
-        unless File.exist?(state_path)
-          Output.json({ error: "STATE.md not found" }, raw: raw)
-          return
-        end
-
-        summary = options["summary"]
-        Output.error("summary required") unless summary
-
-        phase = options["phase"] || "?"
-        rationale = options["rationale"]
-        entry = "- [Phase #{phase}]: #{summary}#{rationale ? " — #{rationale}" : ''}"
-
-        content = File.read(state_path)
-        pattern = /(###?\s*(?:Decisions|Decisions Made|Accumulated.*Decisions)\s*\n)([\s\S]*?)(?=\n###?|\n##[^#]|\z)/i
-
-        if (match = content.match(pattern))
-          body = match[2].gsub(/None yet\.?\s*\n?/i, "").gsub(/No decisions yet\.?\s*\n?/i, "")
-          body = "#{body.rstrip}\n#{entry}\n"
-          content = content.sub(pattern, "#{match[1]}#{body}")
-          File.write(state_path, content)
-          Output.json({ added: true, decision: entry }, raw: raw, raw_value: "true")
-        else
-          Output.json({ added: false, reason: "Decisions section not found" }, raw: raw, raw_value: "false")
-        end
-      end
-
-      def self.add_blocker(text, raw: false)
-        cwd = Dir.pwd
-        state_path = File.join(cwd, ".ariadna_planning", "STATE.md")
-        unless File.exist?(state_path)
-          Output.json({ error: "STATE.md not found" }, raw: raw)
-          return
-        end
-        Output.error("text required") unless text
-
-        content = File.read(state_path)
-        entry = "- #{text}"
-        pattern = /(###?\s*(?:Blockers|Blockers\/Concerns|Concerns)\s*\n)([\s\S]*?)(?=\n###?|\n##[^#]|\z)/i
-
-        if (match = content.match(pattern))
-          body = match[2].gsub(/None\.?\s*\n?/i, "").gsub(/None yet\.?\s*\n?/i, "")
-          body = "#{body.rstrip}\n#{entry}\n"
-          content = content.sub(pattern, "#{match[1]}#{body}")
-          File.write(state_path, content)
-          Output.json({ added: true, blocker: text }, raw: raw, raw_value: "true")
-        else
-          Output.json({ added: false, reason: "Blockers section not found" }, raw: raw, raw_value: "false")
-        end
-      end
-
-      def self.resolve_blocker(text, raw: false)
-        cwd = Dir.pwd
-        state_path = File.join(cwd, ".ariadna_planning", "STATE.md")
-        unless File.exist?(state_path)
-          Output.json({ error: "STATE.md not found" }, raw: raw)
-          return
-        end
-        Output.error("text required") unless text
-
-        content = File.read(state_path)
-        pattern = /(###?\s*(?:Blockers|Blockers\/Concerns|Concerns)\s*\n)([\s\S]*?)(?=\n###?|\n##[^#]|\z)/i
-
-        if (match = content.match(pattern))
-          lines = match[2].split("\n")
-          filtered = lines.reject { |line| line.start_with?("- ") && line.downcase.include?(text.downcase) }
-          new_body = filtered.join("\n")
-          new_body = "None\n" if new_body.strip.empty? || !new_body.include?("- ")
-          content = content.sub(pattern, "#{match[1]}#{new_body}")
-          File.write(state_path, content)
-          Output.json({ resolved: true, blocker: text }, raw: raw, raw_value: "true")
-        else
-          Output.json({ resolved: false, reason: "Blockers section not found" }, raw: raw, raw_value: "false")
-        end
-      end
-
-      def self.record_session(options, raw: false)
-        cwd = Dir.pwd
-        state_path = File.join(cwd, ".ariadna_planning", "STATE.md")
-        unless File.exist?(state_path)
-          Output.json({ error: "STATE.md not found" }, raw: raw)
-          return
-        end
-
-        content = File.read(state_path)
-        now = Time.now.utc.iso8601
-        updated = []
-
-        new_content = replace_field(content, "Last session", now)
-        if new_content
-          content = new_content
-          updated << "Last session"
-        end
-
-        if options["stopped-at"]
-          %w[Stopped At Stopped at].each do |field|
-            new_content = replace_field(content, field, options["stopped-at"])
-            if new_content
-              content = new_content
-              updated << "Stopped At"
-              break
-            end
-          end
-        end
-
-        resume = options["resume-file"] || "None"
-        %w[Resume\ File Resume\ file].each do |field|
-          new_content = replace_field(content, field, resume)
-          if new_content
-            content = new_content
-            updated << "Resume File"
-            break
-          end
-        end
-
-        if updated.any?
-          File.write(state_path, content)
-          Output.json({ recorded: true, updated: updated }, raw: raw, raw_value: "true")
-        else
-          Output.json({ recorded: false, reason: "No session fields found" }, raw: raw, raw_value: "false")
-        end
-      end
-
-      # --- Private helpers ---
-
-      def self.extract_field(content, field_name)
-        pattern = /\*\*#{Regexp.escape(field_name)}:\*\*\s*(.+)/i
-        match = content.match(pattern)
-        match ? match[1].strip : nil
-      end
-
-      def self.replace_field(content, field_name, new_value)
-        escaped = Regexp.escape(field_name)
-        pattern = /(\*\*#{escaped}:\*\*\s*)(.*)/i
-        return nil unless content.match?(pattern)
-
-        content.sub(pattern, "\\1#{new_value}")
-      end
-
       def self.extract_flag(argv, flag)
         idx = argv.index(flag)
         return nil unless idx
@@ -467,32 +201,17 @@ module Ariadna
         argv[idx + 1]
       end
 
-      def self.parse_patches(argv)
-        patches = {}
-        i = 0
-        while i < argv.length
-          if argv[i].start_with?("--")
-            key = argv[i].sub(/\A--/, "")
-            patches[key] = argv[i + 1]
-            i += 2
-          else
-            i += 1
-          end
-        end
-        patches
-      end
-
       def self.parse_named_args(argv, known_keys)
         result = {}
         known_keys.each do |key|
-          flag = "--#{key}"
-          idx = argv.index(flag)
+          idx = argv.index("--#{key}")
           result[key] = argv[idx + 1] if idx
         end
         result
       end
 
-      private_class_method :extract_field, :replace_field, :extract_flag, :parse_patches, :parse_named_args
+      private_class_method :memory_path, :safe_path!, :append_to_memory_file,
+                           :extract_flag, :parse_named_args, :collect_phase_summaries
     end
   end
 end