collavre 0.24.0 → 0.25.0

data/app/controllers/collavre/api/v1/mobile/agent_events_controller.rb

@@ -1,224 +0,0 @@
-# frozen_string_literal: true
-
-module Collavre
-  module Api
-    module V1
-      module Mobile
-        # The heart of the loop. GET surfaces pending approvals (+ recent agent
-        # replies) with a stable spoken ref number and a decision-ready summary.
-        # POST :id/respond branches on the referenced event KIND:
-        #   (A) approval/permission comment → the spoken response is a BUTTON
-        #       press (allow|deny) → decide_claude_channel_permission! + relay.
-        #   (B) ordinary agent message → the spoken response is FREE TEXT passed
-        #       verbatim back to the agent as a reply comment (no server parsing).
-        class AgentEventsController < BaseController
-          # Spoken decision verbs. The app no longer addresses approvals by
-          # ordinal, so a reply to an approval event is just an allow/deny verb;
-          # anything else asks for clarification rather than firing a decision.
-          APPROVE = /(승인|허용|적용|approve|allow|confirm|네|좋아|오케이|\bok\b|\byes\b)/i
-          DENY    = /(거절|거부|반려|deny|reject|취소|아니|\bno\b)/i
-
-          def index
-            approvals = pending_approvals
-            notices = system_inbox_messages
-
-            # Every undecided approval is emitted on every poll — the server keeps
-            # no per-client cursor. Re-speaking is prevented on the CLIENT (an
-            # in-memory "already spoken" set), the same at-least-once shape as
-            # notices: a pending approval keeps surfacing until it is decided
-            # (which clears it from pending_approvals) or the app restarts (when a
-            # still-pending approval SHOULD be re-surfaced). The old `since` cursor
-            # filtered here, but a batch high-water-mark could burn past an approval
-            # whose created_at trailed a newer notice, losing it forever.
-            events = approvals.map do |c|
-              {
-                id: c.id, type: "approval_requested",
-                title: title_for_topic(c.topic_id),
-                summary: summarizer.approval_summary(comment: c, label: label_for_topic(c.topic_id)),
-                speak: true, requires_response: true, topic_id: c.topic_id,
-                created_at: c.created_at.iso8601(6)
-              }
-            end
-
-            events += notices.map do |c|
-              # The notice stands in for the origin comment it quotes; the app
-              # lists/reads it against the ORIGIN thread and replies route there.
-              origin_topic_id = c.quoted_comment&.topic_id || c.topic_id
-              {
-                id: c.id, type: "agent_reply",
-                title: title_for_topic(origin_topic_id),
-                summary: speakable(c.content),
-                speak: true, requires_response: c.quoted_comment_id.present?,
-                topic_id: origin_topic_id, created_at: c.created_at.iso8601(6)
-              }
-            end
-
-            render json: events.sort_by { |e| e[:created_at] }
-          end
-
-          def respond
-            comment = Collavre::Comment.find_by(id: params[:id])
-            unless comment && authorized_comment?(comment)
-              return render json: { error: "Event not found" }, status: :not_found
-            end
-
-            # Acting on a notice means the user has heard it — clear it from the
-            # unread inbox set so it isn't read again on the next poll.
-            mark_inbox_read(comment)
-
-            if comment.claude_channel_permission?
-              decide_on(comment)
-            else
-              relay_free_text(comment)
-            end
-          end
-
-          # The app calls this when it finishes reading a message ALOUD (whether or
-          # not the user then replies). Reading = hearing it, so the inbox read
-          # pointer advances and the notice stops surfacing — the SAME read-state
-          # the inbox badge uses. A crash before this call leaves the notice unread,
-          # so the next poll re-reads it (at-least-once, not the lossy old cursor).
-          def read
-            comment = Collavre::Comment.find_by(id: params[:id])
-            unless comment && authorized_comment?(comment)
-              return render json: { error: "Event not found" }, status: :not_found
-            end
-
-            mark_inbox_read(comment)
-            head :ok
-          end
-
-          private
-
-          # The user's Inbox → System topic is the per-user alarm stream: mentions,
-          # agent replies, share notices, … land here as system-authored
-          # (user_id: nil) comments that QUOTE the origin comment. This is the
-          # canonical, agent-ownership-independent feed the voice loop reads aloud.
-          #
-          # Emission is gated by the inbox's OWN read-state — the CommentReadPointer
-          # (comments with id > last_read_comment_id are unread) that also drives the
-          # inbox badge — NOT by the client's `since` cursor. A `since` cursor is a
-          # fetch-time high-water-mark: any notice fetched-but-never-spoken (crash,
-          # background, busy queue, restart) gets burned past and is lost forever,
-          # even though it stays unread in the inbox. Driving off the read pointer
-          # makes "unread in the inbox" and "read aloud by the app" the same set; the
-          # app marks a notice read (POST :id/read) only after actually speaking it.
-          def system_inbox_messages
-            inbox = current_user_inbox or return []
-            last_read = inbox_read_pointer&.last_read_comment_id || 0
-
-            scope = Collavre::Comment.where(creative_id: inbox.id, topic_id: inbox.system_topic.id)
-                                     .where("comments.id > ?", last_read)
-                                     .order(:id)
-                                     .limit(50)
-            # Approval prompts are surfaced (actionably) by pending_approvals; their
-            # System-topic FYI duplicate must not be read a second time.
-            scope.reject { |c| c.quoted_comment&.claude_channel_permission? }
-          end
-
-          def inbox_read_pointer
-            inbox = current_user_inbox or return nil
-
-            Collavre::CommentReadPointer.find_by(user: current_user, creative: inbox)
-          end
-
-          # Advance the inbox read pointer to (at least) this notice — forward-only,
-          # so a later message is never un-read. Only inbox-creative comments move the
-          # inbox pointer; calling this for an approval (which lives in the origin
-          # creative and is owned by pending_approvals) is a harmless no-op.
-          def mark_inbox_read(comment)
-            inbox = current_user_inbox or return
-            return unless comment.creative_id == inbox.id
-
-            pointer = Collavre::CommentReadPointer.find_or_initialize_by(user: current_user, creative: inbox)
-            new_id = [ pointer.last_read_comment_id || 0, comment.id ].max
-            pointer.update(last_read_comment_id: new_id)
-          end
-
-          def current_user_inbox
-            return @current_user_inbox if defined?(@current_user_inbox)
-
-            @current_user_inbox = Collavre::Creative.inbox_for(current_user)
-          end
-
-          # Read the whole message aloud, but spoken: strip markdown link syntax to
-          # its text and collapse whitespace so TTS doesn't read raw URLs.
-          def speakable(text)
-            text.to_s.gsub(/\[([^\]]+)\]\([^)]*\)/, '\1').gsub(/\s+/, " ").strip
-          end
-
-          def authorized_comment?(comment)
-            return true if comment.approver_id == current_user.id
-            return true if own_inbox_notice?(comment)
-
-            author = comment.user
-            author.respond_to?(:created_by_id) && agent_ids.include?(author.id)
-          end
-
-          # A system-authored notice in the caller's own Inbox#System topic. Owning
-          # the inbox is the authorization proof (the notice has no approver/author).
-          def own_inbox_notice?(comment)
-            inbox = current_user_inbox or return false
-
-            comment.user_id.nil? &&
-              comment.creative_id == inbox.id &&
-              comment.topic_id == inbox.system_topic.id
-          end
-
-          # (A) bounded decision: spoken response IS the approve/deny button.
-          def decide_on(comment)
-            behavior = behavior_from(params[:response])
-
-            unless %w[allow deny].include?(behavior)
-              return render_speak(:clarify_decision, action: { type: "needs_clarification", comment_id: comment.id })
-            end
-
-            case decide_permission(comment, behavior)
-            when :unauthorized
-              render_speak(:not_authorized, action: { type: "not_authorized", comment_id: comment.id }, status: :forbidden)
-            when :already_decided
-              render_speak(:already_decided, action: { type: "already_decided", comment_id: comment.id })
-            else
-              render_speak(
-                behavior == "allow" ? :approved : :denied,
-                action: { type: behavior == "allow" ? "approved" : "denied", comment_id: comment.id }
-              )
-            end
-          end
-
-          # (B) free-form: relay the utterance verbatim as a human reply.
-          def relay_free_text(comment)
-            text = params[:response].to_s.strip
-            return render_speak(:empty_response, action: { type: "noop" }) if text.blank?
-
-            # A System-inbox notice is a stand-in for the origin comment it quotes;
-            # the reply must land on that origin thread (the System topic itself
-            # never dispatches AI), not on the notice.
-            target = comment.quoted_comment || comment
-            topic = target.topic
-            creative = topic&.creative&.effective_origin || target.creative
-            # quoted_comment threads the reply to the message being answered, but
-            # review_type: :question keeps review_message? false — otherwise the
-            # agent's response would update the quoted comment IN PLACE (review flow)
-            # instead of posting a new reply, so no new comment is created and the
-            # Inbox#System alarm never fires. Same guard as InboxReplyService (#1301).
-            reply = creative.comments.create!(
-              content: text, user: current_user, topic: topic,
-              quoted_comment: target, review_type: :question
-            )
-
-            render_speak(:relayed, action: { type: "relayed", comment_id: reply.id, topic_id: topic&.id })
-          end
-
-          def behavior_from(response)
-            text = response.to_s.strip
-            return "allow" if text.match?(APPROVE)
-            return "deny"  if text.match?(DENY)
-
-            nil
-          end
-        end
-      end
-    end
-  end
-end

data/app/controllers/collavre/api/v1/mobile/base_controller.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module Collavre
-  module Api
-    module V1
-      module Mobile
-        # Shared base for the voice-companion mobile API. Inherits Doorkeeper
-        # bearer auth from Api::V1::BaseController.
-        #
-        # ★ The API base controller authenticates the token but does NOT run the
-        # host app's locale around_action, so I18n would otherwise serve the
-        # process-default locale. Every persisted/spoken string here must match
-        # the speaker, so we wrap every action in I18n.with_locale (app-supplied
-        # `locale` param wins, else the user's stored locale).
-        class BaseController < Collavre::Api::V1::BaseController
-          around_action :with_request_locale
-
-          private
-
-          def with_request_locale(&block)
-            I18n.with_locale(requested_locale, &block)
-          end
-
-          def requested_locale
-            normalize_locale(params[:locale].presence || current_user&.locale)
-          end
-
-          def normalize_locale(value)
-            return I18n.default_locale if value.blank?
-
-            base = value.to_s.tr("-", "_").split("_").first.to_sym
-            I18n.available_locales.include?(base) ? base : I18n.default_locale
-          end
-
-          def summarizer
-            @summarizer ||= Collavre::Mobile::EventSummarizer.new(locale: I18n.locale)
-          end
-
-          # User-owned AI agents (Claude Channel sessions, etc.).
-          def agent_ids
-            @agent_ids ||= Collavre::User.ai_agents.where(created_by_id: current_user.id).pluck(:id)
-          end
-
-          # Undecided permission prompts the token holder is the approver for.
-          def pending_approvals
-            Collavre::Comment.where(approver_id: current_user.id, action_executed_at: nil)
-                             .where.not(action: nil)
-                             .order(:created_at)
-                             .limit(50)
-                             .select(&:claude_channel_permission?)
-          end
-
-          def reply(key)
-            I18n.t("collavre.mobile.reply.#{key}")
-          end
-
-          def label_for_topic(topic_id)
-            topic = topic_id && Collavre::Topic.find_by(id: topic_id)
-            topic&.name.presence || I18n.t("collavre.mobile.default_task_label")
-          end
-
-          # List/display title for an event: "Creative#Topic" so the app can show
-          # which thread a message belongs to (spec: 제목을 크리에이티브#토픽 형태로).
-          def title_for_topic(topic_id)
-            topic = topic_id && Collavre::Topic.find_by(id: topic_id)
-            name = topic&.name.presence || I18n.t("collavre.mobile.default_task_label")
-            creative = topic&.creative&.effective_origin || topic&.creative
-            creative&.description.present? ? "#{creative.description}##{name}" : name
-          end
-
-          def render_speak(reply_key_or_text, action: {}, speak: true, status: :ok)
-            text = reply_key_or_text.is_a?(Symbol) ? reply(reply_key_or_text) : reply_key_or_text
-            render json: { reply: text, speak: speak, action: action }, status: status
-          end
-
-          # Gate + decide + broadcast a Claude Channel permission. Routes the
-          # voice path through the same approval_status gate the web path uses
-          # (Comments::ApprovalActions). Without this the caller could decide a
-          # prompt they merely own the authoring agent for but are not the
-          # designated approver of (authorized_comment? lets agent-owned events
-          # through). Returns a symbol: :ok | :unauthorized | :already_decided.
-          def decide_permission(comment, behavior)
-            return :unauthorized unless comment.can_be_approved_by?(current_user)
-
-            comment.decide_claude_channel_permission!(behavior, by: current_user)
-            comment.broadcast_claude_channel_permission_decision(behavior)
-            :ok
-          rescue Collavre::Comment::ClaudeChannelPermission::AlreadyDecided
-            :already_decided
-          end
-        end
-      end
-    end
-  end
-end

data/app/controllers/collavre/api/v1/mobile/devices_controller.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Collavre
-  module Api
-    module V1
-      module Mobile
-        # FCM registration for the Android companion. Push is a follow-up (MVP
-        # uses foreground polling), but registering the device now keeps the
-        # token current so push can light up without a client change.
-        class DevicesController < BaseController
-          def create
-            device = Collavre::Device.find_by(fcm_token: device_params[:fcm_token]) ||
-                     current_user.devices.find_or_initialize_by(client_id: device_params[:client_id])
-
-            device.assign_attributes(device_params)
-            device.user = current_user
-            device.device_type = :android if device.device_type.blank?
-            device.save!
-            head :no_content
-          end
-
-          private
-
-          def device_params
-            params.require(:device).permit(:client_id, :device_type, :app_id, :app_version, :fcm_token)
-          end
-        end
-      end
-    end
-  end
-end

data/app/controllers/collavre/api/v1/mobile/voice_commands_controller.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Collavre
-  module Api
-    module V1
-      module Mobile
-        # A plain mic press (no message selected) routes here: the utterance
-        # starts a new piece of work in the user's Inbox#Main, exactly like
-        # typing in the inbox chat — dispatch then matches an agent via
-        # routing_expression. Replies to a SPECIFIC message go through
-        # agent_events#respond instead (they carry the target event id).
-        class VoiceCommandsController < BaseController
-          def create
-            text = params[:text].to_s.strip
-            return render_speak(:empty_response, action: { type: "noop" }) if text.blank?
-
-            inbox = Collavre::Creative.inbox_for(current_user)
-            comment = inbox.comments.create!(content: text, user: current_user)
-            render_speak(:sent, action: { type: "message_sent", comment_id: comment.id })
-          end
-        end
-      end
-    end
-  end
-end

data/app/controllers/collavre/inbox_items_controller.rb

@@ -1,70 +0,0 @@
-module Collavre
-  class InboxItemsController < ApplicationController
-    before_action :set_inbox_item, only: [ :update, :destroy ]
-
-    PER_PAGE = 20
-
-    def index
-      scope = InboxItem.where(owner: Current.user).order(created_at: :desc)
-      scope = scope.new_items unless params[:show] == "all"
-
-      per_page = params[:per_page].presence&.to_i || PER_PAGE
-      per_page = PER_PAGE if per_page <= 0 || per_page > 100
-      page = params[:page].presence&.to_i || 1
-      page = 1 if page < 1
-      offset = (page - 1) * per_page
-
-      items = scope.offset(offset).limit(per_page + 1).to_a
-      @inbox_items = items.first(per_page)
-      @next_page = items.length > per_page ? page + 1 : nil
-
-      respond_to do |format|
-        format.html do
-          render partial: "collavre/inbox_items/list", locals: { items: @inbox_items, next_page: @next_page }
-        end
-        format.json do
-          render json: {
-            items_html: render_to_string(partial: "collavre/inbox_items/items", formats: [ :html ], locals: { items: @inbox_items }),
-            next_page: @next_page,
-            empty: @inbox_items.empty?
-          }
-        end
-      end
-    end
-
-    def count
-      c = InboxItem.where(owner: Current.user, state: "new").count
-      render json: { count: c }
-    end
-
-    def update
-      unless @inbox_item.owner == Current.user
-        head :forbidden
-        return
-      end
-
-      unless InboxItem.states.key?(params[:state].to_s)
-        head :unprocessable_entity
-        return
-      end
-
-      @inbox_item.update(state: params[:state])
-      head :no_content
-    end
-
-    def destroy
-      if @inbox_item.owner == Current.user
-        @inbox_item.destroy
-        head :no_content
-      else
-        head :forbidden
-      end
-    end
-
-    private
-
-    def set_inbox_item
-      @inbox_item = InboxItem.where(owner: Current.user).find(params[:id])
-    end
-  end
-end

data/app/controllers/collavre/typo_corrections_controller.rb

@@ -1,39 +0,0 @@
-module Collavre
-  # Session-authenticated endpoint backing the inline typo-correction UI. The
-  # frontend also gates by device/location, but we re-check here (fail closed)
-  # before spending an LLM call, and echo the user's auto-apply threshold so the
-  # client never has to hardcode it.
-  class TypoCorrectionsController < ApplicationController
-    # The client debounce is only a hint — a scripted/compromised page can loop
-    # this endpoint with arbitrary text, and every accepted call spends an LLM
-    # request. Bound both the call rate and the per-call size server-side. The
-    # chat composer is short text; anything larger is not a typo-correction case.
-    MAX_TEXT_LENGTH = 4_000
-    RATE_LIMIT = 120          # requests
-    RATE_PERIOD = 1.minute    # ...per user per minute
-
-    def create
-      user = Current.user
-      device = params[:device].to_s
-      location = params[:location].presence || "chat"
-      text = params[:text].to_s
-
-      unless user.typo_correction_active_for?(device: device, location: location)
-        return render json: { edits: [], threshold: user.typo_correction_threshold }
-      end
-
-      # Oversized input: skip the LLM entirely (return no edits, not an error —
-      # this is a background affordance, not a user-facing failure).
-      if text.length > MAX_TEXT_LENGTH
-        return render json: { edits: [], threshold: user.typo_correction_threshold }
-      end
-
-      # Raises RateLimitExceeded -> 429 (DynamicRateLimiting), which the client
-      # treats as "no suggestions this round".
-      check_rate_limit!(key: "typo_correction:#{user.id}", limit: RATE_LIMIT, period: RATE_PERIOD)
-
-      edits = TypoCorrector.new.correct(text)
-      render json: { edits: edits, threshold: user.typo_correction_threshold }
-    end
-  end
-end

data/app/javascript/lib/__tests__/typo_correction.test.js

@@ -1,192 +0,0 @@
-import {
-  detectDevice,
-  shouldRun,
-  buildCandidateList,
-  anchorEdits,
-  applyEditAt,
-  shiftEditsAfter,
-  partitionByThreshold,
-  DEVICE_VOICE,
-  DEVICE_SOFT_KEYBOARD,
-  DEVICE_PHYSICAL_KEYBOARD,
-} from '../typo_correction'
-
-const settings = ({
-  enabled = true,
-  onVoice = true,
-  onSoftKeyboard = true,
-  onPhysicalKeyboard = false,
-  inChat = true,
-  inEditor = false,
-} = {}) => ({ enabled, onVoice, onSoftKeyboard, onPhysicalKeyboard, inChat, inEditor })
-
-describe('detectDevice', () => {
-  test('voice recognition wins regardless of keyboard signals', () => {
-    expect(detectDevice({ voiceActive: true, lastPrintableKeydownAt: 100, inputAt: 110 })).toBe(DEVICE_VOICE)
-  })
-
-  test('printable keydown right before input => physical keyboard', () => {
-    expect(detectDevice({ lastPrintableKeydownAt: 1000, inputAt: 1005 })).toBe(DEVICE_PHYSICAL_KEYBOARD)
-  })
-
-  test('input with no preceding printable keydown => soft keyboard', () => {
-    expect(detectDevice({ lastPrintableKeydownAt: null, inputAt: 1000 })).toBe(DEVICE_SOFT_KEYBOARD)
-  })
-
-  test('stale keydown (too far before input) => soft keyboard', () => {
-    expect(detectDevice({ lastPrintableKeydownAt: 1000, inputAt: 2000 })).toBe(DEVICE_SOFT_KEYBOARD)
-  })
-})
-
-describe('shouldRun (2D gating)', () => {
-  test('runs when master + device + location all on', () => {
-    expect(shouldRun(settings(), { device: DEVICE_SOFT_KEYBOARD, location: 'chat' })).toBe(true)
-  })
-
-  test('blocked when master off', () => {
-    expect(shouldRun(settings({ enabled: false }), { device: DEVICE_SOFT_KEYBOARD, location: 'chat' })).toBe(false)
-  })
-
-  test('physical keyboard off by default blocks even in chat', () => {
-    expect(shouldRun(settings(), { device: DEVICE_PHYSICAL_KEYBOARD, location: 'chat' })).toBe(false)
-  })
-
-  test('editor location off by default blocks even with soft keyboard', () => {
-    expect(shouldRun(settings(), { device: DEVICE_SOFT_KEYBOARD, location: 'editor' })).toBe(false)
-  })
-
-  test('voice in chat runs', () => {
-    expect(shouldRun(settings(), { device: DEVICE_VOICE, location: 'chat' })).toBe(true)
-  })
-
-  test('null settings never runs', () => {
-    expect(shouldRun(null, { device: DEVICE_VOICE, location: 'chat' })).toBe(false)
-  })
-})
-
-describe('buildCandidateList', () => {
-  test('candidate state: original pre-filled, suggestions by confidence', () => {
-    const list = buildCandidateList({
-      currentValue: '안녀하세요',
-      originalWord: '안녀하세요',
-      suggestions: [
-        { suggestion: '안녕하세요', confidence: 0.95 },
-        { suggestion: '안녕하셔요', confidence: 0.4 },
-      ],
-    })
-    expect(list.map((i) => i.value)).toEqual(['안녀하세요', '안녕하세요', '안녕하셔요'])
-    expect(list[0].isCurrent).toBe(true)
-    expect(list[0].role).toBe('original')
-  })
-
-  test('auto-applied state: corrected word current, original offered as undo', () => {
-    const list = buildCandidateList({
-      currentValue: '있습니다',
-      originalWord: '잇습니다',
-      suggestions: [{ suggestion: '있습니다', confidence: 0.99 }],
-    })
-    // current (applied) first, then original (undo); suggestion dupes current and is dropped.
-    expect(list.map((i) => i.value)).toEqual(['있습니다', '잇습니다'])
-    expect(list[0].role).toBe('applied')
-    expect(list[0].isCurrent).toBe(true)
-    expect(list[1].role).toBe('original')
-  })
-
-  test('de-duplicates and skips empties', () => {
-    const list = buildCandidateList({
-      currentValue: 'a',
-      originalWord: 'a',
-      suggestions: [{ suggestion: 'a' }, { suggestion: '' }, { suggestion: 'b', confidence: 0.5 }],
-    })
-    expect(list.map((i) => i.value)).toEqual(['a', 'b'])
-  })
-})
-
-describe('anchorEdits', () => {
-  test('binds offsets to substrings', () => {
-    const text = '안녀하세요 저는 콜라브를 만들고 잇습니다'
-    const edits = anchorEdits(text, [
-      { original: '안녀하세요', suggestion: '안녕하세요' },
-      { original: '잇습니다', suggestion: '있습니다' },
-    ])
-    expect(text.slice(edits[0].start, edits[0].end)).toBe('안녀하세요')
-    expect(text.slice(edits[1].start, edits[1].end)).toBe('잇습니다')
-  })
-
-  test('repeated words anchor to distinct occurrences, not all to the first', () => {
-    const text = 'teh cat and teh dog'
-    const edits = anchorEdits(text, [
-      { original: 'teh', suggestion: 'the' },
-      { original: 'teh', suggestion: 'the' },
-    ])
-    expect(edits[0].start).toBe(0)
-    expect(edits[1].start).toBe(12)
-  })
-
-  test('drops edits whose original is gone', () => {
-    const edits = anchorEdits('hello world', [{ original: 'xyz', suggestion: 'abc' }])
-    expect(edits).toEqual([])
-  })
-
-  test('honors the server offset so a duplicate inside a protected span is skipped', () => {
-    // "teh" appears first inside backticks (a region the server excludes) and
-    // again in plain text at offset 15. A plain search would bind the protected
-    // one; the offset pins us to the valid occurrence.
-    const text = 'use `teh` then teh'
-    const edits = anchorEdits(text, [{ original: 'teh', suggestion: 'the', offset: 15 }])
-    expect(edits[0].start).toBe(15)
-    expect(text.slice(edits[0].start, edits[0].end)).toBe('teh')
-  })
-
-  test('falls back to search when the offset no longer matches the text', () => {
-    const text = 'hello teh'
-    const edits = anchorEdits(text, [{ original: 'teh', suggestion: 'the', offset: 99 }])
-    expect(edits[0].start).toBe(6)
-  })
-})
-
-describe('applyEditAt + shiftEditsAfter (re-anchoring)', () => {
-  test('applying one edit shifts the offsets of later edits', () => {
-    let text = 'teh cat saw teh dog'
-    const edits = anchorEdits(text, [
-      { original: 'teh', suggestion: 'the' },
-      { original: 'teh', suggestion: 'the' },
-    ])
-    const first = edits[0]
-    const { text: t2, delta } = applyEditAt(text, { start: first.start, end: first.end, replacement: 'the' })
-    text = t2
-    expect(text).toBe('the cat saw teh dog')
-    const remaining = shiftEditsAfter(edits.slice(1), first.start, delta)
-    // 'the' and 'teh' are the same length here, delta 0; offset unchanged & still valid.
-    expect(text.slice(remaining[0].start, remaining[0].end)).toBe('teh')
-  })
-
-  test('length-changing replacement re-anchors later edits correctly', () => {
-    let text = 'a wrng word and anothr'
-    const edits = anchorEdits(text, [
-      { original: 'wrng', suggestion: 'wrong' },
-      { original: 'anothr', suggestion: 'another' },
-    ])
-    const first = edits[0]
-    const { text: t2, delta } = applyEditAt(text, { start: first.start, end: first.end, replacement: 'wrong' })
-    text = t2
-    expect(text).toBe('a wrong word and anothr')
-    const remaining = shiftEditsAfter(edits.slice(1), first.start, delta)
-    expect(text.slice(remaining[0].start, remaining[0].end)).toBe('anothr')
-  })
-})
-
-describe('partitionByThreshold', () => {
-  test('splits at/above vs below threshold', () => {
-    const { autoApplied, candidates } = partitionByThreshold(
-      [
-        { original: 'a', confidence: 0.9 },
-        { original: 'b', confidence: 0.8 },
-        { original: 'c', confidence: 0.5 },
-      ],
-      80,
-    )
-    expect(autoApplied.map((e) => e.original)).toEqual(['a', 'b'])
-    expect(candidates.map((e) => e.original)).toEqual(['c'])
-  })
-})