anchor.diff:  
   handle_call(bump_threshold_ts, _From, #state{tab = Tab} = State) ->
       FoldFun = fun(#proc_int{client = nil, pid = Pid}, _) ->
  -        gen_server:cast(Pid, stop),
  -        ets:delete(Tab, Pid);
  +        remove_proc(Tab, Pid);
       (_, _) ->
           ok
       end,
       ets:foldl(FoldFun, nil, Tab),
       {reply, ok, State#state{threshold_ts = os:timestamp()}};
  +
  +handle_call(terminate_stale_procs, _From, State) ->
  +    #state{tab = Tab, threshold_ts = T0} = State,
  +    MatchHead = #proc_int{pid = '$1', t0 = '$2', _ = '_'},
  +    MatchSpec = [{MatchHead, [{'<', '$2', T0}], ['$1']}],
  +    lists:foreach(fun(P) -> remove_proc(Tab,P) end, ets:select(Tab, MatchSpec)),
  +    {reply, ok, State};
   
   handle_call(_Call, _From, State) ->
       {reply, ignored, State}.
  
positive.code:         case get_waiting_client(Waiting, Lang) of
              nil ->
                  if ProcInt#proc_int.t0 < T0 ->
                      gen_server:cast(Pid, stop),
                      ets:delete(Tab, Pid);
                  true ->
                      gen_server:cast(Pid, garbage_collect),
                      ets:insert(Tab, ProcInt#proc_int{client=nil})
  
negative.code:             case dict:find(Lang, Counts) of
                  {ok, Count} when Count > Limit ->
                      ?LOG_INFO("Closing idle OS Process: ~p", [Pid]),
                      remove_proc(Tab, Pid),
                      State0#state{
                          proc_counts=dict:update_counter(Lang, -1, Counts)
                      };
  